From 752bed3311f09e7a43e642231e1638b4252f74a6 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 13 Jan 2011 10:44:29 -0600 Subject: Stubbed out XenServer rescue/unrescue --- nova/virt/xenapi/vmops.py | 8 ++++++++ nova/virt/xenapi_conn.py | 8 ++++++++ 2 files changed, 16 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 7e3585991..8681608e1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -264,6 +264,14 @@ class VMOps(object): task = self._session.call_xenapi('Async.VM.resume', vm, False, True) self._wait_with_callback(task, callback) + def rescue(self, instance, callback): + """Rescue the specified instance""" + return True + + def unrescue(self, instance, callback): + """Unrescue the specified instance""" + return True + def get_info(self, instance_id): """Return data about VM instance""" vm = VMHelper.lookup(self._session, instance_id) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 45d0738a5..c24ec972b 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -169,6 +169,14 @@ class XenAPIConnection(object): """resume the specified instance""" self._vmops.resume(instance, callback) + def rescue(self, instance, callback): + """Rescue the specified instance""" + self._vmops.rescue(instance, callback) + + def unrescue(self, instance, callback): + """Unrescue the specified instance""" + self._vmops.unrescue(instance, callback) + def get_info(self, instance_id): """Return data about VM instance""" return self._vmops.get_info(instance_id) -- cgit From 702d1bd5e58c15e5b7f43e9d56bd591d728ecb71 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 13 Jan 2011 10:47:23 -0600 Subject: Make driver calls compatible --- nova/virt/libvirt_conn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index c03046703..797ac1b60 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -328,7 +328,7 @@ class LibvirtConnection(object): raise exception.APIError("resume not supported for libvirt") @exception.wrap_exception - def rescue(self, instance): + def rescue(self, instance, callback=None): self.destroy(instance, False) xml = self.to_xml(instance, rescue=True) @@ -358,7 +358,7 @@ class LibvirtConnection(object): return timer.start(interval=0.5, now=True) @exception.wrap_exception - def unrescue(self, instance): + def unrescue(self, instance, callback=None): # NOTE(vish): Because reboot destroys and recreates an instance using # the normal xml file, we can just call reboot here self.reboot(instance) -- cgit From fe22186eb989b0302e1cb26a5b92cd77ce47bb9b Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Fri, 14 Jan 2011 16:13:50 +0000 Subject: OS-55: Inject network settings in linux images --- nova/virt/conn_common.py | 50 ++++++++++++++++++++++++++++++++++++++++++++ nova/virt/disk.py | 19 ++++++++++------- nova/virt/libvirt_conn.py | 24 ++++----------------- nova/virt/xenapi/vm_utils.py | 36 +++++++++++++++++++++++++++++++ nova/virt/xenapi/vmops.py | 7 +++++++ 5 files changed, 109 insertions(+), 27 deletions(-) create mode 100644 nova/virt/conn_common.py (limited to 'nova/virt') diff --git a/nova/virt/conn_common.py b/nova/virt/conn_common.py new file mode 100644 index 000000000..bd9ed7794 --- /dev/null +++ b/nova/virt/conn_common.py @@ -0,0 +1,50 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2010 Citrix Systems, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from nova import context +from nova import db +from nova import exception +from nova import flags +from nova import log as logging +from nova import utils + +LOG = logging.getLogger('nova.virt.conn_common') +FLAGS = flags.FLAGS + +flags.DEFINE_string('injected_network_template', + utils.abspath('virt/interfaces.template'), + 'Template file for injected network') + +def get_injectables(inst): + key = str(inst['key_data']) + net = None + network_ref = db.network_get_by_instance(context.get_admin_context(), + inst['id']) + if network_ref['injected']: + admin_context = context.get_admin_context() + address = db.instance_get_fixed_address(admin_context, inst['id']) + ra_server = network_ref['ra_server'] + if not ra_server: + ra_server = "fd00::" + with open(FLAGS.injected_network_template) as f: + net = f.read() % {'address': address, + 'netmask': network_ref['netmask'], + 'gateway': network_ref['gateway'], + 'broadcast': network_ref['broadcast'], + 'dns': network_ref['dns'], + 'ra_server': ra_server} + + return key, net diff --git a/nova/virt/disk.py b/nova/virt/disk.py index c5565abfa..88b05f0c0 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -92,11 +92,7 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): % err) try: - if key: - # inject key file - _inject_key_into_fs(key, tmpdir) - if net: - _inject_net_into_fs(net, tmpdir) + inject_data_into_fs(tmpdir, key, net, execute) finally: # unmount device utils.execute('sudo umount %s' % mapped_device) @@ -158,8 +154,17 @@ def _allocate_device(): def _free_device(device): _DEVICES.append(device) +def inject_data_into_fs(fs, key, net, execute): + """Injects data into a filesystem already mounted by the caller. + Virt connections can call this directly if they mount their fs + in a different way to inject_data + """ + if key: + _inject_key_into_fs(key, fs, execute=execute) + if net: + _inject_net_into_fs(net, fs, execute=execute) -def _inject_key_into_fs(key, fs): +def _inject_key_into_fs(key, fs, execute=None): """Add the given public ssh key to root's authorized_keys. key is an ssh key string. @@ -173,7 +178,7 @@ def _inject_key_into_fs(key, fs): utils.execute('sudo tee -a %s' % keyfile, '\n' + key.strip() + '\n') -def _inject_net_into_fs(net, fs): +def _inject_net_into_fs(net, fs, execute=None): """Inject /etc/network/interfaces into the filesystem rooted at fs. net is the contents of /etc/network/interfaces. diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4e0fd106f..45d8754ab 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -62,6 +62,7 @@ from nova.compute import instance_types from nova.compute import power_state from nova.virt import disk from nova.virt import images +from nova.virt import conn_common libvirt = None libxml2 = None @@ -74,9 +75,7 @@ FLAGS = flags.FLAGS flags.DEFINE_string('rescue_image_id', 'ami-rescue', 'Rescue ami image') flags.DEFINE_string('rescue_kernel_id', 'aki-rescue', 'Rescue aki image') flags.DEFINE_string('rescue_ramdisk_id', 'ari-rescue', 'Rescue ari image') -flags.DEFINE_string('injected_network_template', - utils.abspath('virt/interfaces.template'), - 'Template file for injected network') + flags.DEFINE_string('libvirt_xml_template', utils.abspath('virt/libvirt.xml.template'), 'Libvirt XML Template') @@ -622,23 +621,8 @@ class LibvirtConnection(object): if not inst['kernel_id']: target_partition = "1" - key = str(inst['key_data']) - net = None - network_ref = db.network_get_by_instance(context.get_admin_context(), - inst['id']) - if network_ref['injected']: - admin_context = context.get_admin_context() - address = db.instance_get_fixed_address(admin_context, inst['id']) - ra_server = network_ref['ra_server'] - if not ra_server: - ra_server = "fd00::" - with open(FLAGS.injected_network_template) as f: - net = f.read() % {'address': address, - 'netmask': network_ref['netmask'], - 'gateway': network_ref['gateway'], - 'broadcast': network_ref['broadcast'], - 'dns': network_ref['dns'], - 'ra_server': ra_server} + key, net = conn_common.get_injectables(inst) + if key or net: inst_name = inst['name'] img_id = inst.image_id diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 4bbd522c1..70f81b3b6 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -22,6 +22,7 @@ their attributes like VDIs, VIFs, as well as their lookup functions. import os import pickle import re +import tempfile import time import urllib from xml.dom import minidom @@ -33,10 +34,12 @@ from nova import flags from nova import log as logging from nova import utils from nova.auth.manager import AuthManager +from nova.compute import disk from nova.compute import instance_types from nova.compute import power_state from nova.virt import images from nova.virt.xenapi import HelperBase +from nova.virt import conn_common from nova.virt.xenapi.volume_utils import StorageError @@ -439,6 +442,39 @@ class VMHelper(HelperBase): else: return None + @classmethod + def preconfigure_instance(cls, session, instance, vdi_ref): + """Makes alterations to the image before launching as part of spawn. + May also set xenstore values to modify the image behaviour after + VM start.""" + + # As mounting the image VDI is expensive, we only want do do it once, + # if at all, so determine whether it's required first, and then do + # everything + mount_required = False + key, net = conn_common.get_injectables(instance) + if key is not None or net is not None: + mount_required = True + + if mount_required: + def _mounted_processing(device): + devPath = '/dev/'+device+'1' # Note: Partition 1 hardcoded + tmpdir = tempfile.mkdtemp() + try: + out, err = utils.execute('sudo mount %s %s' % (devPath, tmpdir)) + if err: + raise exception.Error(_('Failed to mount filesystem: %s') % err) + try: + disk.inject_data_into_fs(tmpdir, key, net, utils.execute) + finally: + utils.execute('sudo umount %s' % devPath) + finally: + # remove temporary directory + os.rmdir(tmpdir) + + # FIXME: Check self._session is the type of session this fn wants + with_vdi_attached_here(session, vdi_ref, False, _mounted_processing) + @classmethod def compile_info(cls, record): """Fill record with VM status information""" diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index e84ce20c4..efab9c9ce 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -79,6 +79,9 @@ class VMOps(object): disk_image_type = ImageType.DISK else: disk_image_type = ImageType.DISK_RAW + # TODO: Coalesce fetch_image, lookup_image and + # manipulate_root_image so requires a single VDI mount/umount + # sequence vdi_uuid = VMHelper.fetch_image(self._session, instance.id, instance.image_id, user, project, disk_image_type) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) @@ -102,6 +105,10 @@ class VMOps(object): if network_ref: VMHelper.create_vif(self._session, vm_ref, network_ref, instance.mac_address) + + # Alter the image before VM start for, e.g. network injection + VMHelper.preconfigure_instance(self._session, instance, vdi_ref) + LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) instance_name = instance.name -- cgit From 3300e692b61dc53ac8ae3bfdbac5bb1019983feb Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 17 Jan 2011 12:21:08 -0600 Subject: Add Start/Shutdown support to XenAPI --- nova/virt/xenapi/vmops.py | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 96be17d8c..0e6018973 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -207,6 +207,25 @@ class VMOps(object): logging.debug(_("Finished snapshot and upload for VM %s"), instance) + def start(self, instance): + """Start a VM instance""" + vm = self._get_vm_opaque_ref(instance) + task = self._session.call_xenapi("Async.VM.start", vm, False, False) + self._session.wait_for_task(instance.id, task) + + def shutdown(self, instance, hard=True): + """Shutdown a VM instance""" + vm = self._get_vm_opaque_ref(instance) + if hard: + task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) + else: + # TODO(jk0): clean_shutdown is only supported if XenTools is + # installed and running. What we want to do eventually is try + # this first, and only issue the hard_shutdown if clean_shutdown + # were to fail. + task = self._session.call_xenapi("Async.VM.clean_shutdown", vm) + self._session.wait_for_task(instance.id, task) + def reboot(self, instance): """Reboot VM instance""" vm = self._get_vm_opaque_ref(instance) @@ -320,11 +339,11 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" - return True + self.shutdown(instance) def unrescue(self, instance, callback): """Unrescue the specified instance""" - return True + self.start(instance) def get_info(self, instance): """Return data about VM instance""" -- cgit From 8c79b0c1995bd9d061c1c379c0034f49cbdb8d05 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 17 Jan 2011 13:31:05 -0600 Subject: Better shutdown handling --- nova/virt/xenapi/vmops.py | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 041e2c5bb..f59c1af44 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -213,18 +213,16 @@ class VMOps(object): task = self._session.call_xenapi("Async.VM.start", vm, False, False) self._session.wait_for_task(instance.id, task) - def shutdown(self, instance, hard=True): + def shutdown(self, instance): """Shutdown a VM instance""" vm = self._get_vm_opaque_ref(instance) - if hard: - task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) - else: - # TODO(jk0): clean_shutdown is only supported if XenTools is - # installed and running. What we want to do eventually is try - # this first, and only issue the hard_shutdown if clean_shutdown - # were to fail. + + try: task = self._session.call_xenapi("Async.VM.clean_shutdown", vm) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(instance.id, task) + except self.XenAPI.Failure: + task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) + self._session.wait_for_task(instance.id, task) def reboot(self, instance): """Reboot VM instance""" -- cgit From ecc2afda9fed4e9e69edcc470baf254fac448ce7 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Tue, 18 Jan 2011 15:49:42 -0600 Subject: Plug VBD to existing instance and minor cleanup --- nova/virt/xenapi/fake.py | 2 +- nova/virt/xenapi/vm_utils.py | 12 +++++------- nova/virt/xenapi/vmops.py | 45 +++++++++++++++++++++++++++++++++---------- nova/virt/xenapi/volumeops.py | 2 +- nova/virt/xenapi_conn.py | 15 +++++++++------ 5 files changed, 51 insertions(+), 25 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 96d8f5fc8..92ccfd975 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -335,7 +335,7 @@ class SessionBase(object): field in _db_content[cls][ref]): return _db_content[cls][ref][field] - LOG.debuug(_('Raising NotImplemented')) + LOG.debug(_('Raising NotImplemented')) raise NotImplementedError( _('xenapi.fake does not have an implementation for %s or it has ' 'been called with the wrong number of arguments') % name) diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index eb0393d2a..d5c6a85b4 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -179,9 +179,7 @@ class VMHelper(HelperBase): """Destroy VBD from host database""" try: task = session.call_xenapi('Async.VBD.destroy', vbd_ref) - #FIXME(armando): find a solution to missing instance_id - #with Josh Kearney - session.wait_for_task(0, task) + session.wait_for_task(task) except cls.XenAPI.Failure, exc: LOG.exception(exc) raise StorageError(_('Unable to destroy VBD %s') % vbd_ref) @@ -222,7 +220,7 @@ class VMHelper(HelperBase): original_parent_uuid = get_vhd_parent_uuid(session, vm_vdi_ref) task = session.call_xenapi('Async.VM.snapshot', vm_ref, label) - template_vm_ref = session.wait_for_task(instance_id, task) + template_vm_ref = session.wait_for_task(task, instance_id) template_vdi_rec = get_vdi_for_vm_safely(session, template_vm_ref)[1] template_vdi_uuid = template_vdi_rec["uuid"] @@ -250,7 +248,7 @@ class VMHelper(HelperBase): kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'put_vdis', kwargs) - session.wait_for_task(instance_id, task) + session.wait_for_task(task, instance_id) @classmethod def fetch_image(cls, session, instance_id, image, user, project, type): @@ -272,7 +270,7 @@ class VMHelper(HelperBase): if type == ImageType.DISK_RAW: args['raw'] = 'true' task = session.async_call_plugin('objectstore', fn, args) - uuid = session.wait_for_task(instance_id, task) + uuid = session.wait_for_task(task, instance_id) return uuid @classmethod @@ -409,7 +407,7 @@ def get_vhd_parent_uuid(session, vdi_ref): def scan_sr(session, instance_id, sr_ref): LOG.debug(_("Re-scanning SR %s"), sr_ref) task = session.call_xenapi('Async.SR.scan', sr_ref) - session.wait_for_task(instance_id, task) + session.wait_for_task(task, instance_id) def wait_for_vhd_coalesce(session, instance_id, sr_ref, vdi_ref, diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index f59c1af44..0de7c8d42 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -211,24 +211,23 @@ class VMOps(object): """Start a VM instance""" vm = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi("Async.VM.start", vm, False, False) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) def shutdown(self, instance): """Shutdown a VM instance""" vm = self._get_vm_opaque_ref(instance) - try: task = self._session.call_xenapi("Async.VM.clean_shutdown", vm) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure: task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) def reboot(self, instance): """Reboot VM instance""" vm = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi('Async.VM.clean_reboot', vm) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) def set_admin_password(self, instance, new_pass): """Set the root/admin password on the VM instance. This is done via @@ -284,7 +283,7 @@ class VMOps(object): if shutdown: try: task = self._session.call_xenapi('Async.VM.hard_shutdown', vm) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure, exc: LOG.exception(exc) @@ -293,20 +292,20 @@ class VMOps(object): for vdi in vdis: try: task = self._session.call_xenapi('Async.VDI.destroy', vdi) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure, exc: LOG.exception(exc) # VM Destroy try: task = self._session.call_xenapi('Async.VM.destroy', vm) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure, exc: LOG.exception(exc) def _wait_with_callback(self, instance_id, task, callback): ret = None try: - ret = self._session.wait_for_task(instance_id, task) + ret = self._session.wait_for_task(task, instance_id) except self.XenAPI.Failure, exc: LOG.exception(exc) callback(ret) @@ -337,10 +336,36 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" + vm = self._get_vm_opaque_ref(instance) + target_vm = VMHelper.lookup(self._session, "instance-00000001") + self.shutdown(instance) + vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] + vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] + vbd_ref = VMHelper.create_vbd( + self._session, + target_vm, + vdi_ref, + 1, + False) + + # Plug the VBD into the target instance + self._session.call_xenapi("Async.VBD.plug", vbd_ref) + def unrescue(self, instance, callback): """Unrescue the specified instance""" + vm = self._get_vm_opaque_ref(instance) + target_vm = VMHelper.lookup(self._session, "instance-00000001") + + vbds = self._session.get_xenapi().VM.get_VBDs(target_vm) + + for vbd_ref in vbds: + vbd = self._session.get_xenapi().VBD.get_record(vbd_ref) + if vbd["userdevice"] == str(1): + VMHelper.unplug_vbd(self._session, vbd_ref) + VMHelper.destroy_vbd(self._session, vbd_ref) + self.start(instance) def get_info(self, instance): @@ -425,7 +450,7 @@ class VMOps(object): args.update(addl_args) try: task = self._session.async_call_plugin(plugin, method, args) - ret = self._session.wait_for_task(instance_id, task) + ret = self._session.wait_for_task(task, instance_id) except self.XenAPI.Failure, e: ret = None err_trace = e.details[-1] diff --git a/nova/virt/xenapi/volumeops.py b/nova/virt/xenapi/volumeops.py index 189f968c6..0c5f36f6b 100644 --- a/nova/virt/xenapi/volumeops.py +++ b/nova/virt/xenapi/volumeops.py @@ -85,7 +85,7 @@ class VolumeOps(object): try: task = self._session.call_xenapi('Async.VBD.plug', vbd_ref) - self._session.wait_for_task(vol_rec['deviceNumber'], task) + self._session.wait_for_task(task, vol_rec['deviceNumber']) except self.XenAPI.Failure, exc: LOG.exception(exc) VolumeHelper.destroy_iscsi_storage(self._session, diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index e9793e6a7..07bc0fd84 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -290,7 +290,7 @@ class XenAPISession(object): self._session.xenapi.Async.host.call_plugin, self.get_xenapi_host(), plugin, fn, args) - def wait_for_task(self, id, task): + def wait_for_task(self, task, id=None): """Return the result of the given task. The task is polled until it completes. Not re-entrant.""" done = event.Event() @@ -317,10 +317,11 @@ class XenAPISession(object): try: name = self._session.xenapi.task.get_name_label(task) status = self._session.xenapi.task.get_status(task) - action = dict( - instance_id=int(id), - action=name[0:255], # Ensure action is never > 255 - error=None) + if id: + action = dict( + instance_id=int(id), + action=name[0:255], # Ensure action is never > 255 + error=None) if status == "pending": return elif status == "success": @@ -339,7 +340,9 @@ class XenAPISession(object): status, error_info)) done.send_exception(self.XenAPI.Failure(error_info)) - db.instance_action_create(context.get_admin_context(), action) + + if id: + db.instance_action_create(context.get_admin_context(), action) except self.XenAPI.Failure, exc: LOG.warn(exc) done.send_exception(*sys.exc_info()) -- cgit From 2c0f1d78927c14f1d155e617a066b09a00acb100 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 18 Jan 2011 17:40:36 -0600 Subject: Basic stubbing throughout the stack --- nova/virt/fake.py | 12 ++++++++++++ nova/virt/xenapi/vmops.py | 4 ++++ nova/virt/xenapi_conn.py | 4 ++++ 3 files changed, 20 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index a57a8f43b..a6fe24c3e 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -138,6 +138,18 @@ class FakeConnection(object): """ pass + def resize(self, instance, flavor): + """ + Resizes/Migrates the specified instance. + + The flavor parameter determines whether or not the instance RAM and + disk space are modified, and if so, to what size. + + The work will be done asynchronously. This function returns a task + that allows the caller to detect when it is complete. + """ + pass + def set_admin_password(self, instance, new_pass): """ Set the root password on the specified instance. diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6e359ef82..50ee24325 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -207,6 +207,10 @@ class VMOps(object): logging.debug(_("Finished snapshot and upload for VM %s"), instance) + def resize(self, instance, flavor): + """Resize a running instance by changing it's RAM and disk size """ + raise NotImplementedError() + def reboot(self, instance): """Reboot VM instance""" vm = self._get_vm_opaque_ref(instance) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 689844f34..c850dbf80 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -145,6 +145,10 @@ class XenAPIConnection(object): """ Create snapshot from a running VM instance """ self._vmops.snapshot(instance, name) + def resize(self, instance, flavor): + """Resize a VM instance""" + raise NotImplementedError() + def reboot(self, instance): """Reboot VM instance""" self._vmops.reboot(instance) -- cgit From bb727b7032104d3d3966108d846dd3e5b8a1a37d Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Tue, 18 Jan 2011 17:59:26 -0600 Subject: Fix merge conflict --- nova/virt/xenapi/vm_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 9600584b4..5f5ac254d 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -329,7 +329,7 @@ class VMHelper(HelperBase): #let the plugin copy the correct number of bytes args['image-size'] = str(vdi_size) task = session.async_call_plugin('glance', fn, args) - filename = session.wait_for_task(instance_id, task) + filename = session.wait_for_task(task, instance_id) #remove the VDI as it is not needed anymore session.get_xenapi().VDI.destroy(vdi) LOG.debug(_("Kernel/Ramdisk VDI %s destroyed"), vdi) -- cgit From dd70c9f3909c800d72d73d507e9da05a6ed932de Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 19 Jan 2011 11:20:16 -0600 Subject: Fixed unit tests --- nova/virt/xenapi/vm_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 5f5ac254d..7484472d7 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -371,7 +371,7 @@ class VMHelper(HelperBase): args = {} args['vdi-ref'] = vdi_ref task = session.async_call_plugin('objectstore', fn, args) - pv_str = session.wait_for_task(instance_id, task) + pv_str = session.wait_for_task(task, instance_id) pv = None if pv_str.lower() == 'true': pv = True -- cgit From 88be6540d2a796e313f2d8ef4ccc6e66ba1a3ed1 Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Thu, 20 Jan 2011 16:49:54 +0000 Subject: OS-55: Only modify Linux image with no or injection-incapable guest agent OS-55: Support network configuration via xenstore for Windows images --- nova/virt/xenapi/vm_utils.py | 105 +++++++++++++++++++++++++++++++++++++++---- nova/virt/xenapi/vmops.py | 3 ++ 2 files changed, 99 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 70f81b3b6..79d529ce2 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -29,6 +29,8 @@ from xml.dom import minidom from eventlet import event import glance.client +from nova import context +from nova import db from nova import exception from nova import flags from nova import log as logging @@ -458,22 +460,107 @@ class VMHelper(HelperBase): if mount_required: def _mounted_processing(device): - devPath = '/dev/'+device+'1' # Note: Partition 1 hardcoded + devPath = '/dev/'+device+'1' # NB: Partition 1 hardcoded tmpdir = tempfile.mkdtemp() try: - out, err = utils.execute('sudo mount %s %s' % (devPath, tmpdir)) - if err: - raise exception.Error(_('Failed to mount filesystem: %s') % err) + # Mount only Linux filesystems, as we mustn't disturb NTFS images try: - disk.inject_data_into_fs(tmpdir, key, net, utils.execute) - finally: - utils.execute('sudo umount %s' % devPath) + out, err = utils.execute('sudo mount -t ext2,ext3 "%s" "%s"' % (devPath, tmpdir)) + except exception.ProcessExecutionError as e: + err = str(e) + if err: + LOG.info('Failed to mount filesystem (expected for non-linux instances): %s' % err) + else: + try: + # This try block ensures that the umount occurs + + xe_update_networking_filename = os.path.join(tmpdir, 'usr', 'sbin', 'xe-update-networking') + if os.path.isfile(xe_update_networking_filename): + # The presence of the xe-update-networking file indicates that this guest + # agent can reconfigure the netwokr from xenstore data, so manipulation + # of files in /etc is not required + LOG.info('XenServer tools installed in this image are capable of network injection. ' + 'Networking files will not be manipulated') + else: + xe_daemon_filename = os.path.join(tmpdir, 'usr', 'sbin', 'xe-daemon') + if os.path.isfile(xe_daemon_filename): + LOG.info('XenServer tools are present in this image but ' + 'are not capable of network injection') + else: + LOG.info('XenServer tools are not installed in this image') + LOG.info('Manipulating interface files directly') + disk.inject_data_into_fs(tmpdir, key, net, utils.execute) + finally: + utils.execute('sudo umount "%s"' % devPath) finally: # remove temporary directory os.rmdir(tmpdir) - - # FIXME: Check self._session is the type of session this fn wants + with_vdi_attached_here(session, vdi_ref, False, _mounted_processing) + + + @classmethod + def preconfigure_xenstore(cls, session, instance, vm_ref): + XENSTORE_TYPES = { + 'BroadcastAddress' : 'multi_sz', + 'DefaultGateway' : 'multi_sz', + 'EnableDhcp' : 'dword', + 'IPAddress' : 'multi_sz', + 'NameServer' : 'string', + 'SubnetMask' : 'multi_sz' + } + + # Network setup + network_ref = db.network_get_by_instance(context.get_admin_context(), + instance['id']) + if network_ref['injected']: + admin_context = context.get_admin_context() + address = db.instance_get_fixed_address(admin_context, instance['id']) + + xenstore_data = { + # NB: Setting broadcast address is not supported by + # Windows or the Windows guest agent, and will be ignored + # on that platform + 'BroadcastAddress': network_ref['broadcast'], + 'EnableDhcp': '0', + 'IPAddress': address, + 'SubnetMask': network_ref['netmask'], + 'DefaultGateway': network_ref['gateway'], + 'NameServer': network_ref['dns'] + } + + device_to_configure = 0 # Configure network device 0 in the VM + + vif_refs = session.call_xenapi('VM.get_VIFs', vm_ref) + mac_addr = None + + for vif_ref in vif_refs: + device = session.call_xenapi('VIF.get_device', vif_ref) + if str(device) == str(device_to_configure): + mac_addr = session.call_xenapi('VIF.get_MAC', vif_ref) + break + + if mac_addr is None: + raise exception.NotFound('Networking device %s not found in VM') + + # MAC address must be upper case in the xenstore key, + # with colons replaced by underscores + underscore_mac_addr = mac_addr.replace(':', '_') + xenstore_prefix='vm-data/vif/'+underscore_mac_addr.upper()+'/tcpip/' + + for xenstore_key, xenstore_value in xenstore_data.iteritems(): + # NB: The xenstore_key part of the instance_key isn't used but must + # be unique. We set it to xenstore_key as a convenient unique name. + # The xenstore_key value takes effect in the /name element. + instance_key = xenstore_prefix + xenstore_key + type = XENSTORE_TYPES[xenstore_key] + + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/name', xenstore_key) + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/type', type) + if type == 'multi_sz': + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/data/0', xenstore_value) + else: + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/data', xenstore_value) @classmethod def compile_info(cls, record): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index efab9c9ce..ae477f11e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -109,6 +109,9 @@ class VMOps(object): # Alter the image before VM start for, e.g. network injection VMHelper.preconfigure_instance(self._session, instance, vdi_ref) + # Configure the VM's xenstore data before start for, e.g. network configuration + VMHelper.preconfigure_xenstore(self._session, instance, vm_ref) + LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) instance_name = instance.name -- cgit From 8f531ef7c0782feba46f83ec2e45d113753c4052 Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Thu, 20 Jan 2011 19:51:23 +0000 Subject: OS-55: pylint fixes --- nova/virt/xenapi/vm_utils.py | 96 ++++++++++++++++++++++++++++---------------- nova/virt/xenapi/vmops.py | 3 +- 2 files changed, 63 insertions(+), 36 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 79d529ce2..eb699d715 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -447,8 +447,7 @@ class VMHelper(HelperBase): @classmethod def preconfigure_instance(cls, session, instance, vdi_ref): """Makes alterations to the image before launching as part of spawn. - May also set xenstore values to modify the image behaviour after - VM start.""" + """ # As mounting the image VDI is expensive, we only want do do it once, # if at all, so determine whether it's required first, and then do @@ -460,38 +459,53 @@ class VMHelper(HelperBase): if mount_required: def _mounted_processing(device): - devPath = '/dev/'+device+'1' # NB: Partition 1 hardcoded + """Callback whioch runds with the image VDI attached""" + + dev_path = '/dev/'+device+'1' # NB: Partition 1 hardcoded tmpdir = tempfile.mkdtemp() try: - # Mount only Linux filesystems, as we mustn't disturb NTFS images + # Mount only Linux filesystems, to avoid disturbing + # NTFS images try: - out, err = utils.execute('sudo mount -t ext2,ext3 "%s" "%s"' % (devPath, tmpdir)) + _, err = utils.execute( + 'sudo mount -t ext2,ext3 "%s" "%s"' % + (dev_path, tmpdir)) except exception.ProcessExecutionError as e: err = str(e) if err: - LOG.info('Failed to mount filesystem (expected for non-linux instances): %s' % err) + LOG.info(_('Failed to mount filesystem (expected for ' + 'non-linux instances): %s') % err) else: try: # This try block ensures that the umount occurs - xe_update_networking_filename = os.path.join(tmpdir, 'usr', 'sbin', 'xe-update-networking') + xe_update_networking_filename = os.path.join(tmpdir, + 'usr', 'sbin', 'xe-update-networking') if os.path.isfile(xe_update_networking_filename): - # The presence of the xe-update-networking file indicates that this guest - # agent can reconfigure the netwokr from xenstore data, so manipulation - # of files in /etc is not required - LOG.info('XenServer tools installed in this image are capable of network injection. ' - 'Networking files will not be manipulated') + # The presence of the xe-update-networking + # file indicates that this guest agent can + # reconfigure the network from xenstore data, + # so manipulation of files in /etc is not + # required + LOG.info(_('XenServer tools installed in this ' + 'image are capable of network injection. ' + 'Networking files will not be manipulated')) else: - xe_daemon_filename = os.path.join(tmpdir, 'usr', 'sbin', 'xe-daemon') + xe_daemon_filename = os.path.join(tmpdir, 'usr', + 'sbin', 'xe-daemon') if os.path.isfile(xe_daemon_filename): - LOG.info('XenServer tools are present in this image but ' - 'are not capable of network injection') + LOG.info(_('XenServer tools are present in ' + 'this image but are not capable of ' + 'network injection')) else: - LOG.info('XenServer tools are not installed in this image') - LOG.info('Manipulating interface files directly') - disk.inject_data_into_fs(tmpdir, key, net, utils.execute) + LOG.info(_('XenServer tools are not ' + 'installed in this image')) + LOG.info(_('Manipulating interface files ' + 'directly')) + disk.inject_data_into_fs(tmpdir, key, net, + utils.execute) finally: - utils.execute('sudo umount "%s"' % devPath) + utils.execute('sudo umount "%s"' % dev_path) finally: # remove temporary directory os.rmdir(tmpdir) @@ -501,7 +515,11 @@ class VMHelper(HelperBase): @classmethod def preconfigure_xenstore(cls, session, instance, vm_ref): - XENSTORE_TYPES = { + """Sets xenstore values to modify the image behaviour after + VM start. + """ + + xenstore_types = { 'BroadcastAddress' : 'multi_sz', 'DefaultGateway' : 'multi_sz', 'EnableDhcp' : 'dword', @@ -511,11 +529,12 @@ class VMHelper(HelperBase): } # Network setup - network_ref = db.network_get_by_instance(context.get_admin_context(), - instance['id']) + network_ref = db.network_get_by_instance( + context.get_admin_context(), instance['id']) if network_ref['injected']: admin_context = context.get_admin_context() - address = db.instance_get_fixed_address(admin_context, instance['id']) + address = db.instance_get_fixed_address(admin_context, + instance['id']) xenstore_data = { # NB: Setting broadcast address is not supported by @@ -541,26 +560,33 @@ class VMHelper(HelperBase): break if mac_addr is None: - raise exception.NotFound('Networking device %s not found in VM') + raise exception.NotFound(_('Networking device %s not found ' + 'in VM')) # MAC address must be upper case in the xenstore key, # with colons replaced by underscores underscore_mac_addr = mac_addr.replace(':', '_') - xenstore_prefix='vm-data/vif/'+underscore_mac_addr.upper()+'/tcpip/' + xenstore_prefix = ('vm-data/vif/' + + underscore_mac_addr.upper() + '/tcpip/') for xenstore_key, xenstore_value in xenstore_data.iteritems(): - # NB: The xenstore_key part of the instance_key isn't used but must - # be unique. We set it to xenstore_key as a convenient unique name. - # The xenstore_key value takes effect in the /name element. + # NB: The xenstore_key part of the instance_key isn't used but + # must be unique. We set it to xenstore_key as a convenient + # unique name...The xenstore_key value takes effect in the + # /name element. instance_key = xenstore_prefix + xenstore_key - type = XENSTORE_TYPES[xenstore_key] - - session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/name', xenstore_key) - session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/type', type) - if type == 'multi_sz': - session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/data/0', xenstore_value) + key_type = xenstore_types[xenstore_key] + + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, + instance_key+'/name', xenstore_key) + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, + instance_key+'/type', key_type) + if key_type == 'multi_sz': + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, + instance_key+'/data/0', xenstore_value) else: - session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key+'/data', xenstore_value) + session.call_xenapi('VM.add_to_xenstore_data', vm_ref, + instance_key+'/data', xenstore_value) @classmethod def compile_info(cls, record): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ae477f11e..df282807a 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -109,7 +109,8 @@ class VMOps(object): # Alter the image before VM start for, e.g. network injection VMHelper.preconfigure_instance(self._session, instance, vdi_ref) - # Configure the VM's xenstore data before start for, e.g. network configuration + # Configure the VM's xenstore data before start for, + # e.g. network configuration VMHelper.preconfigure_xenstore(self._session, instance, vm_ref) LOG.debug(_('Starting VM %s...'), vm_ref) -- cgit From 089bdfa8c2f0f116b55c69bbcde6fca6632cb145 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 20 Jan 2011 15:20:23 -0600 Subject: should be writing some kindof network info to the xenstore now, hopefully --- nova/virt/xenapi/vmops.py | 39 +++++++++++++++++++++++++++++++-------- 1 file changed, 31 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6c2fd6a68..882b9d9d6 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -67,11 +67,6 @@ class VMOps(object): raise exception.Duplicate(_('Attempted to create' ' non-unique name %s') % instance.name) - bridge = db.network_get_by_instance(context.get_admin_context(), - instance['id'])['bridge'] - network_ref = \ - NetworkHelper.find_network_with_bridge(self._session, bridge) - user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) #if kernel is not present we must download a raw disk @@ -99,9 +94,29 @@ class VMOps(object): instance, kernel, ramdisk, pv_kernel) VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) - if network_ref: - VMHelper.create_vif(self._session, vm_ref, - network_ref, instance.mac_address) + # write network info + network = db.network_get_by_instance(context.get_admin_context(), + instance['id']) + for network in db.network_get_all(): + mapping = {'label': network['label'], + 'gateway': network['gateway'], + 'mac': instance.mac_address, + 'dns': network['dns'], + 'ips': [{'netmask': network['netmask'], + 'enabled': '1', + 'ip': 192.168.3.3}]} # <===== CHANGE!!!! + self.write_network_config_to_xenstore(vm_ref, mapping) + + bridge = network['bridge'] + network_ref = \ + NetworkHelper.find_network_with_bridge(self._session, bridge) + + if network_ref: + VMHelper.create_vif(self._session, vm_ref, + network_ref, instance.mac_address) + + # call reset networking + LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) LOG.info(_('Spawning VM %s created %s.'), instance.name, vm_ref) @@ -341,6 +356,14 @@ class VMOps(object): # TODO: implement this! return 'http://fakeajaxconsole/fake_url' + def reset_networking(self, instance): + vm = self._get_vm_opaque_ref(instance) + self.write_to_xenstore(vm, "resetnetwork", "") + + def write_network_config_to_xenstore(self, instance): + vm = self._get_vm_opaque_ref(instance) + self.write_to_param_xenstore(vm, mapping) + def list_from_xenstore(self, vm, path): """Runs the xenstore-ls command to get a listing of all records from 'path' downward. Returns a dict with the sub-paths as keys, -- cgit From 9b993d50835c79d23dca422335de362ebaf7f4fa Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 20 Jan 2011 15:47:08 -0600 Subject: added plugin call for resetnetworking --- nova/virt/xenapi/vmops.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 882b9d9d6..7f9e78df5 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -358,7 +358,8 @@ class VMOps(object): def reset_networking(self, instance): vm = self._get_vm_opaque_ref(instance) - self.write_to_xenstore(vm, "resetnetwork", "") + args = {'id': str(uuid.uuid4())} + resp = self._make_agent_call('resetnetwork', vm, '', args) def write_network_config_to_xenstore(self, instance): vm = self._get_vm_opaque_ref(instance) -- cgit From f77043d44aa640e1811a3fe236fc8fd5dfecf990 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 20 Jan 2011 16:27:09 -0600 Subject: syntax --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 7f9e78df5..1045d5d98 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -104,7 +104,7 @@ class VMOps(object): 'dns': network['dns'], 'ips': [{'netmask': network['netmask'], 'enabled': '1', - 'ip': 192.168.3.3}]} # <===== CHANGE!!!! + 'ip': '192.168.3.3'}]} # <===== CHANGE!!!! self.write_network_config_to_xenstore(vm_ref, mapping) bridge = network['bridge'] -- cgit From 1dbdb180cb93a812f8336bbfc49bf67a5203d1eb Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Fri, 21 Jan 2011 12:00:45 +0000 Subject: OS-55: Fix current unit tests --- nova/virt/xenapi/fake.py | 4 ++++ nova/virt/xenapi/vm_utils.py | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index e8352771c..836252730 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -161,6 +161,10 @@ def after_VBD_create(vbd_ref, vbd_rec): vm_name_label = _db_content['VM'][vm_ref]['name_label'] vbd_rec['vm_name_label'] = vm_name_label +def after_VM_create(vm_ref, vm_rec): + """Create read-only fields in the VM record.""" + if 'is_control_domain' not in vm_rec: + vm_rec['is_control_domain'] = False def create_pbd(config, host_ref, sr_ref, attached): return _create_object('PBD', { diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index eb699d715..9b78a178a 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -459,7 +459,7 @@ class VMHelper(HelperBase): if mount_required: def _mounted_processing(device): - """Callback whioch runds with the image VDI attached""" + """Callback which runs with the image VDI attached""" dev_path = '/dev/'+device+'1' # NB: Partition 1 hardcoded tmpdir = tempfile.mkdtemp() @@ -467,7 +467,7 @@ class VMHelper(HelperBase): # Mount only Linux filesystems, to avoid disturbing # NTFS images try: - _, err = utils.execute( + out, err = utils.execute( 'sudo mount -t ext2,ext3 "%s" "%s"' % (dev_path, tmpdir)) except exception.ProcessExecutionError as e: -- cgit From 9039c2cc59904a72fc71255a3a31ec2b17018963 Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Fri, 21 Jan 2011 16:06:32 +0000 Subject: OS-55: Added unit test for network injection via xenstore --- nova/virt/xenapi/fake.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 836252730..f9ae8766a 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -148,7 +148,15 @@ def create_vbd(vm_ref, vdi_ref): after_VBD_create(vbd_ref, vbd_rec) return vbd_ref - +def VM_get_xenstore_data(vm_ref): + return _db_content['VM'][vm_ref].get('xenstore_data', '') + +def VM_add_to_xenstore_data(vm_ref, key, value): + db_ref = _db_content['VM'][vm_ref] + if not 'xenstore_data' in db_ref: + db_ref['xenstore_data'] = {} + db_ref['xenstore_data'][key] = value + def after_VBD_create(vbd_ref, vbd_rec): """Create read-only fields and backref from VM to VBD when VBD is created.""" @@ -401,7 +409,7 @@ class SessionBase(object): field in _db_content[cls][ref]): return _db_content[cls][ref][field] - LOG.debuug(_('Raising NotImplemented')) + LOG.debug(_('Raising NotImplemented')) raise NotImplementedError( _('xenapi.fake does not have an implementation for %s or it has ' 'been called with the wrong number of arguments') % name) -- cgit From c97618e1eaff4091f01381073a298d0f67050126 Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Mon, 24 Jan 2011 18:28:50 +0000 Subject: OS-55: Post-merge fixes --- nova/virt/xenapi/vm_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 9b78a178a..68946a2bb 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -36,9 +36,9 @@ from nova import flags from nova import log as logging from nova import utils from nova.auth.manager import AuthManager -from nova.compute import disk from nova.compute import instance_types from nova.compute import power_state +from nova.virt import disk from nova.virt import images from nova.virt.xenapi import HelperBase from nova.virt import conn_common -- cgit From cd346a2cda13833f976b9e838d67cf17c52f327e Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Mon, 24 Jan 2011 19:04:25 +0000 Subject: OS-55: PEP8 fixes --- nova/virt/conn_common.py | 3 +- nova/virt/disk.py | 2 ++ nova/virt/xenapi/fake.py | 9 +++-- nova/virt/xenapi/vm_utils.py | 80 ++++++++++++++++++++++---------------------- nova/virt/xenapi/vmops.py | 6 ++-- 5 files changed, 54 insertions(+), 46 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/conn_common.py b/nova/virt/conn_common.py index bd9ed7794..5550b50c1 100644 --- a/nova/virt/conn_common.py +++ b/nova/virt/conn_common.py @@ -27,7 +27,8 @@ FLAGS = flags.FLAGS flags.DEFINE_string('injected_network_template', utils.abspath('virt/interfaces.template'), 'Template file for injected network') - + + def get_injectables(inst): key = str(inst['key_data']) net = None diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 88b05f0c0..21bb53369 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -154,6 +154,7 @@ def _allocate_device(): def _free_device(device): _DEVICES.append(device) + def inject_data_into_fs(fs, key, net, execute): """Injects data into a filesystem already mounted by the caller. Virt connections can call this directly if they mount their fs @@ -164,6 +165,7 @@ def inject_data_into_fs(fs, key, net, execute): if net: _inject_net_into_fs(net, fs, execute=execute) + def _inject_key_into_fs(key, fs, execute=None): """Add the given public ssh key to root's authorized_keys. diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index f9ae8766a..561e47911 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -148,15 +148,18 @@ def create_vbd(vm_ref, vdi_ref): after_VBD_create(vbd_ref, vbd_rec) return vbd_ref + def VM_get_xenstore_data(vm_ref): return _db_content['VM'][vm_ref].get('xenstore_data', '') - + + def VM_add_to_xenstore_data(vm_ref, key, value): db_ref = _db_content['VM'][vm_ref] if not 'xenstore_data' in db_ref: db_ref['xenstore_data'] = {} db_ref['xenstore_data'][key] = value - + + def after_VBD_create(vbd_ref, vbd_rec): """Create read-only fields and backref from VM to VBD when VBD is created.""" @@ -169,11 +172,13 @@ def after_VBD_create(vbd_ref, vbd_rec): vm_name_label = _db_content['VM'][vm_ref]['name_label'] vbd_rec['vm_name_label'] = vm_name_label + def after_VM_create(vm_ref, vm_rec): """Create read-only fields in the VM record.""" if 'is_control_domain' not in vm_rec: vm_rec['is_control_domain'] = False + def create_pbd(config, host_ref, sr_ref, attached): return _create_object('PBD', { 'device-config': config, diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 68946a2bb..fa60c44c3 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -448,7 +448,7 @@ class VMHelper(HelperBase): def preconfigure_instance(cls, session, instance, vdi_ref): """Makes alterations to the image before launching as part of spawn. """ - + # As mounting the image VDI is expensive, we only want do do it once, # if at all, so determine whether it's required first, and then do # everything @@ -456,12 +456,13 @@ class VMHelper(HelperBase): key, net = conn_common.get_injectables(instance) if key is not None or net is not None: mount_required = True - + if mount_required: + def _mounted_processing(device): """Callback which runs with the image VDI attached""" - - dev_path = '/dev/'+device+'1' # NB: Partition 1 hardcoded + + dev_path = '/dev/' + device + '1' # NB: Partition 1 hardcoded tmpdir = tempfile.mkdtemp() try: # Mount only Linux filesystems, to avoid disturbing @@ -478,9 +479,9 @@ class VMHelper(HelperBase): else: try: # This try block ensures that the umount occurs - - xe_update_networking_filename = os.path.join(tmpdir, - 'usr', 'sbin', 'xe-update-networking') + + xe_update_networking_filename = os.path.join( + tmpdir, 'usr', 'sbin', 'xe-update-networking') if os.path.isfile(xe_update_networking_filename): # The presence of the xe-update-networking # file indicates that this guest agent can @@ -489,14 +490,15 @@ class VMHelper(HelperBase): # required LOG.info(_('XenServer tools installed in this ' 'image are capable of network injection. ' - 'Networking files will not be manipulated')) + 'Networking files will not be' + 'manipulated')) else: - xe_daemon_filename = os.path.join(tmpdir, 'usr', - 'sbin', 'xe-daemon') + xe_daemon_filename = os.path.join(tmpdir, + 'usr', 'sbin', 'xe-daemon') if os.path.isfile(xe_daemon_filename): - LOG.info(_('XenServer tools are present in ' - 'this image but are not capable of ' - 'network injection')) + LOG.info(_('XenServer tools are present ' + 'in this image but are not capable ' + 'of network injection')) else: LOG.info(_('XenServer tools are not ' 'installed in this image')) @@ -510,24 +512,23 @@ class VMHelper(HelperBase): # remove temporary directory os.rmdir(tmpdir) - with_vdi_attached_here(session, vdi_ref, False, _mounted_processing) - - + with_vdi_attached_here(session, vdi_ref, False, + _mounted_processing) + @classmethod def preconfigure_xenstore(cls, session, instance, vm_ref): """Sets xenstore values to modify the image behaviour after VM start. """ - + xenstore_types = { - 'BroadcastAddress' : 'multi_sz', - 'DefaultGateway' : 'multi_sz', - 'EnableDhcp' : 'dword', - 'IPAddress' : 'multi_sz', - 'NameServer' : 'string', - 'SubnetMask' : 'multi_sz' - } - + 'BroadcastAddress': 'multi_sz', + 'DefaultGateway': 'multi_sz', + 'EnableDhcp': 'dword', + 'IPAddress': 'multi_sz', + 'NameServer': 'string', + 'SubnetMask': 'multi_sz'} + # Network setup network_ref = db.network_get_by_instance( context.get_admin_context(), instance['id']) @@ -535,8 +536,8 @@ class VMHelper(HelperBase): admin_context = context.get_admin_context() address = db.instance_get_fixed_address(admin_context, instance['id']) - - xenstore_data = { + + xenstore_data = { # NB: Setting broadcast address is not supported by # Windows or the Windows guest agent, and will be ignored # on that platform @@ -545,30 +546,29 @@ class VMHelper(HelperBase): 'IPAddress': address, 'SubnetMask': network_ref['netmask'], 'DefaultGateway': network_ref['gateway'], - 'NameServer': network_ref['dns'] - } - - device_to_configure = 0 # Configure network device 0 in the VM - + 'NameServer': network_ref['dns']} + + device_to_configure = 0 # Configure network device 0 in the VM + vif_refs = session.call_xenapi('VM.get_VIFs', vm_ref) mac_addr = None - + for vif_ref in vif_refs: device = session.call_xenapi('VIF.get_device', vif_ref) if str(device) == str(device_to_configure): mac_addr = session.call_xenapi('VIF.get_MAC', vif_ref) break - + if mac_addr is None: raise exception.NotFound(_('Networking device %s not found ' 'in VM')) - + # MAC address must be upper case in the xenstore key, # with colons replaced by underscores underscore_mac_addr = mac_addr.replace(':', '_') xenstore_prefix = ('vm-data/vif/' + underscore_mac_addr.upper() + '/tcpip/') - + for xenstore_key, xenstore_value in xenstore_data.iteritems(): # NB: The xenstore_key part of the instance_key isn't used but # must be unique. We set it to xenstore_key as a convenient @@ -578,15 +578,15 @@ class VMHelper(HelperBase): key_type = xenstore_types[xenstore_key] session.call_xenapi('VM.add_to_xenstore_data', vm_ref, - instance_key+'/name', xenstore_key) + instance_key + '/name', xenstore_key) session.call_xenapi('VM.add_to_xenstore_data', vm_ref, - instance_key+'/type', key_type) + instance_key + '/type', key_type) if key_type == 'multi_sz': session.call_xenapi('VM.add_to_xenstore_data', vm_ref, - instance_key+'/data/0', xenstore_value) + instance_key + '/data/0', xenstore_value) else: session.call_xenapi('VM.add_to_xenstore_data', vm_ref, - instance_key+'/data', xenstore_value) + instance_key + '/data', xenstore_value) @classmethod def compile_info(cls, record): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index df282807a..9eea19c42 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -105,14 +105,14 @@ class VMOps(object): if network_ref: VMHelper.create_vif(self._session, vm_ref, network_ref, instance.mac_address) - + # Alter the image before VM start for, e.g. network injection VMHelper.preconfigure_instance(self._session, instance, vdi_ref) - + # Configure the VM's xenstore data before start for, # e.g. network configuration VMHelper.preconfigure_xenstore(self._session, instance, vm_ref) - + LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) instance_name = instance.name -- cgit From 671f27322156615643ce9194a26bec66819c0c78 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 26 Jan 2011 10:34:57 -0600 Subject: Cleaned up _start() and _shutdown() --- nova/virt/xenapi/vmops.py | 39 ++++++++++++++++----------------------- 1 file changed, 16 insertions(+), 23 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index e348aee95..e4aff2313 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -208,22 +208,6 @@ class VMOps(object): logging.debug(_("Finished snapshot and upload for VM %s"), instance) - def start(self, instance): - """Start a VM instance""" - vm = self._get_vm_opaque_ref(instance) - task = self._session.call_xenapi("Async.VM.start", vm, False, False) - self._session.wait_for_task(task, instance.id) - - def shutdown(self, instance): - """Shutdown a VM instance""" - vm = self._get_vm_opaque_ref(instance) - try: - task = self._session.call_xenapi("Async.VM.clean_shutdown", vm) - self._session.wait_for_task(task, instance.id) - except self.XenAPI.Failure: - task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) - self._session.wait_for_task(task, instance.id) - def reboot(self, instance): """Reboot VM instance""" vm = self._get_vm_opaque_ref(instance) @@ -268,8 +252,13 @@ class VMOps(object): raise RuntimeError(resp_dict['message']) return resp_dict['message'] + def _start(self, instance, vm): + """Start an instance""" + task = self._session.call_xenapi("Async.VM.start", vm, False, False) + self._session.wait_for_task(task, instance.id) + def _shutdown(self, instance, vm): - """Shutdown an instance """ + """Shutdown an instance""" state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: LOG.warn(_("VM %(vm)s already halted, skipping shutdown...") % @@ -277,8 +266,12 @@ class VMOps(object): return try: - task = self._session.call_xenapi('Async.VM.hard_shutdown', vm) - self._session.wait_for_task(task, instance.id) + try: + task = self._session.call_xenapi("Async.VM.clean_shutdown", vm) + self._session.wait_for_task(task, instance.id) + except self.XenAPI.Failure: + task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) + self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure, exc: LOG.exception(exc) @@ -368,9 +361,9 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" vm = self._get_vm_opaque_ref(instance) - target_vm = VMHelper.lookup(self._session, "instance-00000001") + target_vm = VMHelper.lookup(self._session, "instance-00000012") - self.shutdown(instance) + self._shutdown(instance, vm) vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] @@ -387,7 +380,7 @@ class VMOps(object): def unrescue(self, instance, callback): """Unrescue the specified instance""" vm = self._get_vm_opaque_ref(instance) - target_vm = VMHelper.lookup(self._session, "instance-00000001") + target_vm = VMHelper.lookup(self._session, "instance-00000012") vbds = self._session.get_xenapi().VM.get_VBDs(target_vm) @@ -397,7 +390,7 @@ class VMOps(object): VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) - self.start(instance) + self._start(instance, vm) def get_info(self, instance): """Return data about VM instance""" -- cgit From 0c7893e4119bcccdfdfdcdef0931fcc8802688e8 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Wed, 26 Jan 2011 14:59:17 -0600 Subject: added mapping parameter to write_network_config_to_xenstore --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index c7310987b..68fa1ecd6 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -391,7 +391,7 @@ class VMOps(object): args = {'id': str(uuid.uuid4())} resp = self._make_agent_call('resetnetwork', vm, '', args) - def write_network_config_to_xenstore(self, instance): + def write_network_config_to_xenstore(self, instance, mapping): vm = self._get_vm_opaque_ref(instance) self.write_to_param_xenstore(vm, mapping) -- cgit From 7c8096384507908a5e583f4554d0fc765ae5f2eb Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Thu, 27 Jan 2011 20:39:33 +0900 Subject: adding testcode --- nova/virt/fake.py | 12 ++-- nova/virt/libvirt_conn.py | 159 ++++++++++++++++++++++++---------------------- nova/virt/xenapi_conn.py | 14 ++-- 3 files changed, 101 insertions(+), 84 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 80ae7f34c..f469af681 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -316,15 +316,15 @@ class FakeConnection(object): def get_vcpu_number(self): """This method is supported only libvirt. """ - return -1 + return def get_memory_mb(self): """This method is supported only libvirt..""" - return -1 + return def get_local_gb(self): """This method is supported only libvirt..""" - return -1 + return def get_hypervisor_type(self): """This method is supported only libvirt..""" @@ -332,12 +332,16 @@ class FakeConnection(object): def get_hypervisor_version(self): """This method is supported only libvirt..""" - return -1 + return def compare_cpu(self, xml): """This method is supported only libvirt..""" raise NotImplementedError('This method is supported only libvirt.') + def ensure_filtering_rules_for_instance(self, instance_ref): + """This method is supported only libvirt..""" + raise NotImplementedError('This method is supported only libvirt.') + def live_migration(self, context, instance_ref, dest): """This method is supported only libvirt..""" raise NotImplementedError('This method is supported only libvirt.') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7d1f76b32..49dd03c57 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -861,18 +861,18 @@ class LibvirtConnection(object): def get_cpu_info(self): """ Get cpuinfo information """ - xmlstr = self._conn.getCapabilities() - xml = libxml2.parseDoc(xmlstr) + xml = self._conn.getCapabilities() + xml = libxml2.parseDoc(xml) nodes = xml.xpathEval('//cpu') if len(nodes) != 1: - msg = 'Unexpected xml format. tag "cpu" must be 1, but %d.' \ - % len(nodes) + msg = 'Invalid xml. "" must be 1, but %d.' % len(nodes) msg += '\n' + xml.serialize() raise exception.Invalid(_(msg)) - arch = xml.xpathEval('//cpu/arch')[0].getContent() - model = xml.xpathEval('//cpu/model')[0].getContent() - vendor = xml.xpathEval('//cpu/vendor')[0].getContent() + cpu_info = dict() + cpu_info['arch'] = xml.xpathEval('//cpu/arch')[0].getContent() + cpu_info['model'] = xml.xpathEval('//cpu/model')[0].getContent() + cpu_info['vendor'] = xml.xpathEval('//cpu/vendor')[0].getContent() topology_node = xml.xpathEval('//cpu/topology')[0].get_properties() topology = dict() @@ -890,18 +890,19 @@ class LibvirtConnection(object): feature_nodes = xml.xpathEval('//cpu/feature') features = list() for nodes in feature_nodes: - feature_name = nodes.get_properties().getContent() - features.append(feature_name) + features.append(nodes.get_properties().getContent()) template = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """ """"topology":{"cores":"%s", "threads":"%s", """ """"sockets":"%s"}, "features":[%s]}""") - c = topology['cores'] - s = topology['sockets'] - t = topology['threads'] f = ['"%s"' % x for x in features] - cpu_info = template % (arch, model, vendor, c, s, t, ', '.join(f)) - return cpu_info + return template % (cpu_info['arch'], + cpu_info['model'], + cpu_info['vendor'], + topology['cores'], + topology['sockets'], + topology['threads'], + ', '.join(f)) def block_stats(self, instance_name, disk): """ @@ -935,12 +936,12 @@ class LibvirtConnection(object): def compare_cpu(self, cpu_info): """ - Check the host cpu is compatible to a cpu given by xml. - "xml" must be a part of libvirt.openReadonly().getCapabilities(). - return values follows by virCPUCompareResult. - if 0 > return value, do live migration. + Check the host cpu is compatible to a cpu given by xml. + "xml" must be a part of libvirt.openReadonly().getCapabilities(). + return values follows by virCPUCompareResult. + if 0 > return value, do live migration. - 'http://libvirt.org/html/libvirt-libvirt.html#virCPUCompareResult' + 'http://libvirt.org/html/libvirt-libvirt.html#virCPUCompareResult' """ msg = _('Checking cpu_info: instance was launched this cpu.\n: %s ') LOG.info(msg % cpu_info) @@ -952,7 +953,7 @@ class LibvirtConnection(object): url = 'http://libvirt.org/html/libvirt-libvirt.html' url += '#virCPUCompareResult\n' msg = 'CPU does not have compativility.\n' - msg += 'result:%d \n' + msg += 'result:%s \n' msg += 'Refer to %s' msg = _(msg) @@ -960,7 +961,7 @@ class LibvirtConnection(object): try: ret = self._conn.compareCPU(xml, 0) except libvirt.libvirtError, e: - LOG.error(msg % (ret, url)) + LOG.error(msg % (e.message, url)) raise e if ret <= 0: @@ -969,24 +970,26 @@ class LibvirtConnection(object): return def ensure_filtering_rules_for_instance(self, instance_ref): - """ Setting up inevitable filtering rules on compute node, - and waiting for its completion. - To migrate an instance, filtering rules to hypervisors - and firewalls are inevitable on destination host. - ( Waiting only for filterling rules to hypervisor, - since filtering rules to firewall rules can be set faster). - - Concretely, the below method must be called. - - setup_basic_filtering (for nova-basic, etc.) - - prepare_instance_filter(for nova-instance-instance-xxx, etc.) - - to_xml may have to be called since it defines PROJNET, PROJMASK. - but libvirt migrates those value through migrateToURI(), - so , no need to be called. - - Don't use thread for this method since migration should - not be started when setting-up filtering rules operations - are not completed.""" + """ + Setting up inevitable filtering rules on compute node, + and waiting for its completion. + To migrate an instance, filtering rules to hypervisors + and firewalls are inevitable on destination host. + ( Waiting only for filterling rules to hypervisor, + since filtering rules to firewall rules can be set faster). + + Concretely, the below method must be called. + - setup_basic_filtering (for nova-basic, etc.) + - prepare_instance_filter(for nova-instance-instance-xxx, etc.) + + to_xml may have to be called since it defines PROJNET, PROJMASK. + but libvirt migrates those value through migrateToURI(), + so , no need to be called. + + Don't use thread for this method since migration should + not be started when setting-up filtering rules operations + are not completed. + """ # Tf any instances never launch at destination host, # basic-filtering must be set here. @@ -1009,40 +1012,44 @@ class LibvirtConnection(object): raise exception.Error(msg % (ec2_id, instance_ref.name)) time.sleep(0.5) - def live_migration(self, context, instance_ref, dest): + def live_migration(self, ctxt, instance_ref, dest): """ - Just spawning live_migration operation for - distributing high-load. + Just spawning live_migration operation for + distributing high-load. """ - greenthread.spawn(self._live_migration, context, instance_ref, dest) + greenthread.spawn(self._live_migration, ctxt, instance_ref, dest) - def _live_migration(self, context, instance_ref, dest): + def _live_migration(self, ctxt, instance_ref, dest): """ Do live migration.""" # Do live migration. try: - duri = FLAGS.live_migration_uri % dest - flaglist = FLAGS.live_migration_flag.split(',') flagvals = [getattr(libvirt, x.strip()) for x in flaglist] logical_sum = reduce(lambda x, y: x | y, flagvals) - bandwidth = FLAGS.live_migration_bandwidth - if self.read_only: tmpconn = self._connect(self.libvirt_uri, False) dom = tmpconn.lookupByName(instance_ref.name) - dom.migrateToURI(duri, logical_sum, None, bandwidth) + dom.migrateToURI(FLAGS.live_migration_uri % dest, + logical_sum, + None, + FLAGS.live_migration_bandwidth) tmpconn.close() else: dom = self._conn.lookupByName(instance_ref.name) - dom.migrateToURI(duri, logical_sum, None, bandwidth) + dom.migrateToURI(FLAGS.live_migration_uri % dest, + logical_sum, + None, + FLAGS.live_migration_bandwidth) except Exception, e: - id = instance_ref['id'] - db.instance_set_state(context, id, power_state.RUNNING, 'running') + db.instance_set_state(ctxt, + instance_ref['id'], + power_state.RUNNING, + 'running') for v in instance_ref['volumes']: - db.volume_update(context, + db.volume_update(ctxt, v['id'], {'status': 'in-use'}) @@ -1052,20 +1059,20 @@ class LibvirtConnection(object): timer = utils.LoopingCall(f=None) def wait_for_live_migration(): - + """waiting for live migration completion""" try: - state = self.get_info(instance_ref.name)['state'] + self.get_info(instance_ref.name)['state'] except exception.NotFound: timer.stop() - self._post_live_migration(context, instance_ref, dest) + self._post_live_migration(ctxt, instance_ref, dest) timer.f = wait_for_live_migration timer.start(interval=0.5, now=True) - def _post_live_migration(self, context, instance_ref, dest): + def _post_live_migration(self, ctxt, instance_ref, dest): """ - Post operations for live migration. - Mainly, database updating. + Post operations for live migration. + Mainly, database updating. """ LOG.info('post livemigration operation is started..') # Detaching volumes. @@ -1079,61 +1086,61 @@ class LibvirtConnection(object): 'nova.virt.libvirt_conn.IptablesFirewallDriver': try: self.firewall_driver.unfilter_instance(instance_ref) - except KeyError, e: + except KeyError: pass # Database updating. ec2_id = instance_ref['hostname'] instance_id = instance_ref['id'] - fixed_ip = db.instance_get_fixed_address(context, instance_id) + fixed_ip = db.instance_get_fixed_address(ctxt, instance_id) # Not return if fixed_ip is not found, otherwise, # instance never be accessible.. if None == fixed_ip: logging.warn('fixed_ip is not found for %s ' % ec2_id) - db.fixed_ip_update(context, fixed_ip, {'host': dest}) - network_ref = db.fixed_ip_get_network(context, fixed_ip) - db.network_update(context, network_ref['id'], {'host': dest}) + db.fixed_ip_update(ctxt, fixed_ip, {'host': dest}) + network_ref = db.fixed_ip_get_network(ctxt, fixed_ip) + db.network_update(ctxt, network_ref['id'], {'host': dest}) try: floating_ip \ - = db.instance_get_floating_address(context, instance_id) + = db.instance_get_floating_address(ctxt, instance_id) # Not return if floating_ip is not found, otherwise, # instance never be accessible.. if None == floating_ip: - logging.error('floating_ip is not found for %s ' % ec2_id) + LOG.info(_('floating_ip is not found for %s'), ec2_id) else: - floating_ip_ref = db.floating_ip_get_by_address(context, + floating_ip_ref = db.floating_ip_get_by_address(ctxt, floating_ip) - db.floating_ip_update(context, + db.floating_ip_update(ctxt, floating_ip_ref['address'], {'host': dest}) except exception.NotFound: - logging.debug('%s doesnt have floating_ip.. ' % ec2_id) + LOG.info(_('floating_ip is not found for %s'), ec2_id) except: - msg = 'Live migration: Unexpected error:' - msg += '%s cannot inherit floating ip.. ' % ec2_id - logging.error(_(msg)) + msg = ("""Live migration: Unexpected error:""" + """%s cannot inherit floating ip..""") + LOG.error(_(msg), ec2_id) # Restore instance/volume state - db.instance_update(context, + db.instance_update(ctxt, instance_id, {'state_description': 'running', 'state': power_state.RUNNING, 'host': dest}) for v in instance_ref['volumes']: - db.volume_update(context, + db.volume_update(ctxt, v['id'], {'status': 'in-use'}) - logging.info(_('Live migrating %s to %s finishes successfully') + LOG.info(_('Live migrating %s to %s finishes successfully') % (ec2_id, dest)) msg = _(("""Known error: the below error is nomally occurs.\n""" """Just check if iinstance is successfully migrated.\n""" """libvir: QEMU error : Domain not found: no domain """ """with matching name..""")) - logging.info(msg) + LOG.info(msg) class FirewallDriver(object): diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index c10f73fe7..1e7933f51 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -215,15 +215,15 @@ class XenAPIConnection(object): def get_vcpu_number(self): """This method is supported only libvirt. """ - return -1 + return def get_memory_mb(self): """This method is supported only libvirt..""" - return -1 + return def get_local_gb(self): """This method is supported only libvirt..""" - return -1 + return def get_hypervisor_type(self): """This method is supported only libvirt..""" @@ -231,12 +231,18 @@ class XenAPIConnection(object): def get_hypervisor_version(self): """This method is supported only libvirt..""" - return -1 + return def compare_cpu(self, xml): + """This method is supported only libvirt..""" + raise NotImplementedError('This method is supported only libvirt.') + + def ensure_filtering_rules_for_instance(self, instance_ref): + """This method is supported only libvirt..""" raise NotImplementedError('This method is supported only libvirt.') def live_migration(self, context, instance_ref, dest): + """This method is supported only libvirt..""" raise NotImplementedError('This method is supported only libvirt.') -- cgit From 46456155d42dd8a668b370fa84972c388094e1d8 Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Fri, 28 Jan 2011 18:40:19 +0000 Subject: OS-55: Fix typo for libvirt_conn operation --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 21bb53369..98121df2a 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -92,7 +92,7 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): % err) try: - inject_data_into_fs(tmpdir, key, net, execute) + inject_data_into_fs(tmpdir, key, net, utils.execute) finally: # unmount device utils.execute('sudo umount %s' % mapped_device) -- cgit From 09f2c4729456443c4874a8cadc53299817d6371a Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Mon, 31 Jan 2011 18:41:10 +0900 Subject: 1. Discard nova-manage host list Reason: nova-manage service list can be replacement. Changes: nova-manage 2. Fix resource checking inappropriate design. Reason: nova.scheduler.driver.has_enough_resource has inappropriate design, so fix it. This method didnt check free memory but check total memory. We need to register free memory onto databases(periodically). But periodically updating may causes flooding request to db in case of many compute-node. Currently, since memory information is only used in this feature, we take the choice that administrators manually has to execute nova-manage to let compute node update their own memory information. Changes: nova.db.sqlalchemy.models - Adding memory_mb_used, local_gb_used, vcpu_used column to Service. (local_gb and vcpu is just for reference to admins for now) nova.compute.manager - Changing nova.compute.manager.update_service Service table column is changed, so updating method must be changed. - Adding nova.compute.manager.update_available_resource a responder to admin's request to let compute nodes update their memory infomation nova.virt.libvirt_conn nova.virt.xenapi_conn nova.virt.fake - Adding getter method for memory_mb_used/local_gb_used/vcpu_used. nova-manage - request method to let compute nodes update their own memory info. --- nova/virt/fake.py | 22 +++++++++++++++++----- nova/virt/libvirt_conn.py | 37 ++++++++++++++++++++++++++++++------- nova/virt/xenapi_conn.py | 22 +++++++++++++++++----- 3 files changed, 64 insertions(+), 17 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index f469af681..4bf477f5b 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -314,16 +314,28 @@ class FakeConnection(object): """This method is supported only libvirt. """ return - def get_vcpu_number(self): + def get_vcpu_total(self): """This method is supported only libvirt. """ return - def get_memory_mb(self): - """This method is supported only libvirt..""" + def get_memory_mb_total(self): + """This method is supported only libvirt. """ return - def get_local_gb(self): - """This method is supported only libvirt..""" + def get_local_gb_total(self): + """This method is supported only libvirt. """ + return + + def get_vcpu_used(self): + """This method is supported only libvirt. """ + return + + def get_memory_mb_used(self): + """This method is supported only libvirt. """ + return + + def get_local_gb_used(self): + """This method is supported only libvirt. """ return def get_hypervisor_type(self): diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 49dd03c57..aefa32dcb 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -835,21 +835,44 @@ class LibvirtConnection(object): return interfaces - def get_vcpu_number(self): + def get_vcpu_total(self): """ Get vcpu number of physical computer. """ - return self._conn.getMaxVcpus(None) + return open('/proc/cpuinfo').read().count('processor') - def get_memory_mb(self): - """Get the memory size of physical computer .""" + def get_memory_mb_total(self): + """Get the total memory size(MB) of physical computer .""" meminfo = open('/proc/meminfo').read().split() idx = meminfo.index('MemTotal:') # transforming kb to mb. return int(meminfo[idx + 1]) / 1024 - def get_local_gb(self): - """Get the hdd size of physical computer .""" + def get_local_gb_total(self): + """Get the total hdd size(GB) of physical computer .""" hddinfo = os.statvfs(FLAGS.instances_path) - return hddinfo.f_bsize * hddinfo.f_blocks / 1024 / 1024 / 1024 + return hddinfo.f_frsize * hddinfo.f_blocks / 1024 / 1024 / 1024 + + def get_vcpu_used(self): + """ Get vcpu available number of physical computer. """ + total = 0 + for i in self._conn.listDomainsID(): + dom = self._conn.lookupByID(i) + total += len(dom.vcpus()[1]) + return total + + def get_memory_mb_used(self): + """Get the free memory size(MB) of physical computer.""" + m = open('/proc/meminfo').read().split() + idx1 = m.index('MemFree:') + idx2 = m.index('Buffers:') + idx3 = m.index('Cached:') + avail = (int(m[idx1+1]) + int(m[idx2+1]) + int(m[idx3+1])) / 1024 + return self.get_memory_mb_total() - avail + + def get_local_gb_used(self): + """Get the free hdd size(GB) of physical computer .""" + hddinfo = os.statvfs(FLAGS.instances_path) + avail = hddinfo.f_frsize * hddinfo.f_bavail / 1024 / 1024 / 1024 + return self.get_local_gb_total() - avail def get_hypervisor_type(self): """ Get hypervisor type """ diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 1e7933f51..902879d09 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -213,16 +213,28 @@ class XenAPIConnection(object): """This method is supported only libvirt. """ return - def get_vcpu_number(self): + def get_vcpu_total(self): """This method is supported only libvirt. """ return - def get_memory_mb(self): - """This method is supported only libvirt..""" + def get_memory_mb_total(self): + """This method is supported only libvirt. """ return - def get_local_gb(self): - """This method is supported only libvirt..""" + def get_local_gb_total(self): + """This method is supported only libvirt. """ + return + + def get_vcpu_used(self): + """This method is supported only libvirt. """ + return + + def get_memory_mb_used(self): + """This method is supported only libvirt. """ + return + + def get_local_gb_used(self): + """This method is supported only libvirt. """ return def get_hypervisor_type(self): -- cgit From 620eba09a96f25a059249c23a5e73efd18aaf89a Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Tue, 1 Feb 2011 14:11:21 -0600 Subject: forgot context param for network_get_all --- nova/virt/xenapi/vmops.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 68fa1ecd6..da2e5c672 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -95,9 +95,10 @@ class VMOps(object): VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) # write network info - network = db.network_get_by_instance(context.get_admin_context(), + admin_context = context.get_admin_context() + network = db.network_get_by_instance(admin_context, instance['id']) - for network in db.network_get_all(): + for network in db.network_get_all(admin_context): mapping = {'label': network['label'], 'gateway': network['gateway'], 'mac': instance.mac_address, -- cgit From 0e6b1c02b3ae82526f3cf83ce70213e7a107701d Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Tue, 1 Feb 2011 15:41:53 -0600 Subject: added to inject networking data into the xenstore --- nova/virt/xenapi/vmops.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index da2e5c672..6edeae5c0 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -99,14 +99,16 @@ class VMOps(object): network = db.network_get_by_instance(admin_context, instance['id']) for network in db.network_get_all(admin_context): + mac_id = instance.mac_address.replace(':', '') + location = 'vm-data/networking/%s' % mac_id mapping = {'label': network['label'], 'gateway': network['gateway'], 'mac': instance.mac_address, - 'dns': network['dns'], + 'dns': [network['dns']], 'ips': [{'netmask': network['netmask'], 'enabled': '1', 'ip': '192.168.3.3'}]} # <===== CHANGE!!!! - self.write_network_config_to_xenstore(vm_ref, mapping) + self.write_to_param_xenstore(vm_ref, {location: mapping}) bridge = network['bridge'] network_ref = \ @@ -392,10 +394,6 @@ class VMOps(object): args = {'id': str(uuid.uuid4())} resp = self._make_agent_call('resetnetwork', vm, '', args) - def write_network_config_to_xenstore(self, instance, mapping): - vm = self._get_vm_opaque_ref(instance) - self.write_to_param_xenstore(vm, mapping) - def list_from_xenstore(self, vm, path): """Runs the xenstore-ls command to get a listing of all records from 'path' downward. Returns a dict with the sub-paths as keys, -- cgit From 9be0770208b0e75c7d93ba10165b82d5be11be27 Mon Sep 17 00:00:00 2001 From: Ken Pepple Date: Thu, 3 Feb 2011 17:57:46 -0800 Subject: flagged all INSTANCE_TYPES usage with FIXME comment. Added basic usage to nova-manage (needs formatting). created api methods. --- nova/virt/libvirt_conn.py | 2 ++ nova/virt/xenapi/vm_utils.py | 1 + 2 files changed, 3 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index bd5c9c4ee..9ed6d4a71 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -611,6 +611,7 @@ class LibvirtConnection(object): user=user, project=project, size=size) + # FIX-ME(kpepple) for dynamic flavors type_data = instance_types.INSTANCE_TYPES[inst['instance_type']] if type_data['local_gb']: @@ -671,6 +672,7 @@ class LibvirtConnection(object): network = db.network_get_by_instance(context.get_admin_context(), instance['id']) # FIXME(vish): stick this in db + # FIX-ME(kpepple) for dynamic flavors instance_type = instance['instance_type'] instance_type = instance_types.INSTANCE_TYPES[instance_type] ip_address = db.instance_get_fixed_address(context.get_admin_context(), diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 4afd28dd8..4d09b2afa 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -82,6 +82,7 @@ class VMHelper(HelperBase): the pv_kernel flag indicates whether the guest is HVM or PV """ + # FIX-ME(kpepple) for dynamic flavors instance_type = instance_types.INSTANCE_TYPES[instance.instance_type] mem = str(long(instance_type['memory_mb']) * 1024 * 1024) vcpus = str(instance_type['vcpus']) -- cgit From b65e994d9597f0a989b30eafc7a51bc34c4c361f Mon Sep 17 00:00:00 2001 From: Cerberus Date: Fri, 4 Feb 2011 15:13:18 -0600 Subject: Added a bunch of stubbed out functionality --- nova/virt/xenapi/vmops.py | 18 ++++++++++++++++-- nova/virt/xenapi_conn.py | 11 +++++++++++ 2 files changed, 27 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3f9eb39d1..468881355 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -60,6 +60,15 @@ class VMOps(object): vms.append(rec["name_label"]) return vms + def power_on(self, instance): + """Power on a VM instance""" + vm = VMHelper.lookup(self._session, instance.name) + if vm is None: + raise exception(_('Attempted to power on non-existent instance' + ' bad instance id %s') % instance.id) + LOG.debug(_("Starting instance %s"), instance.name) + self._session.call_xenapi('VM.start', vm, False, False) + def spawn(self, instance): """Create VM instance""" vm = VMHelper.lookup(self._session, instance.name) @@ -259,7 +268,8 @@ class VMOps(object): raise RuntimeError(resp_dict['message']) return resp_dict['message'] - def _shutdown(self, instance, vm): + + def _shutdown(self, instance, vm, method='hard'): """Shutdown an instance """ state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: @@ -268,7 +278,11 @@ class VMOps(object): return try: - task = self._session.call_xenapi('Async.VM.hard_shutdown', vm) + task = None + if method == 'clean': + task = self._session.call_xenapi('Async.VM.clean_shutdown', vm) + else: + task = self._session.call_xenapi('Async.VM.hard_shutdown', vm) self._session.wait_for_task(instance.id, task) except self.XenAPI.Failure, exc: LOG.exception(exc) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 4637b4c29..628291764 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -184,6 +184,17 @@ class XenAPIConnection(object): """Unpause paused VM instance""" self._vmops.unpause(instance, callback) + def power_off(self, instance): + """Shuts down a running VM instance""" + self._vmops._shutdown(instance, method='clean') + + def power_on(self, instance): + """powers on a powered off VM instance""" + self._vmops.power_on(instance) + + def transfer_disk(self, instance, dest, callback): + self._vmops.transfer_disk( + def suspend(self, instance, callback): """suspend the specified instance""" self._vmops.suspend(instance, callback) -- cgit From 25a5afbb783e28bd5303853bf09e4b254c938302 Mon Sep 17 00:00:00 2001 From: Ken Pepple Date: Sat, 5 Feb 2011 01:14:45 -0800 Subject: added FIXME(kpepple) comments for all constant usage of INSTANCE_TYPES. updated api/ec2/admin.py to use the new instance_types db table --- nova/virt/libvirt_conn.py | 4 ++-- nova/virt/xenapi/vm_utils.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9ed6d4a71..e66115464 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -611,7 +611,7 @@ class LibvirtConnection(object): user=user, project=project, size=size) - # FIX-ME(kpepple) for dynamic flavors + # FIXME(kpepple) for dynamic flavors type_data = instance_types.INSTANCE_TYPES[inst['instance_type']] if type_data['local_gb']: @@ -672,7 +672,7 @@ class LibvirtConnection(object): network = db.network_get_by_instance(context.get_admin_context(), instance['id']) # FIXME(vish): stick this in db - # FIX-ME(kpepple) for dynamic flavors + # FIXME(kpepple) for dynamic flavors instance_type = instance['instance_type'] instance_type = instance_types.INSTANCE_TYPES[instance_type] ip_address = db.instance_get_fixed_address(context.get_admin_context(), diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 4d09b2afa..3f0112609 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -82,7 +82,7 @@ class VMHelper(HelperBase): the pv_kernel flag indicates whether the guest is HVM or PV """ - # FIX-ME(kpepple) for dynamic flavors + # FIXME(kpepple) for dynamic flavors instance_type = instance_types.INSTANCE_TYPES[instance.instance_type] mem = str(long(instance_type['memory_mb']) * 1024 * 1024) vcpus = str(instance_type['vcpus']) -- cgit From b6022c1f7d7dc9294f6b1b613c7e99bd9437a72e Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 7 Feb 2011 13:43:23 -0600 Subject: added network_get_all_by_instance(), call to reset_network in vmops --- nova/virt/xenapi/vmops.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6edeae5c0..4056e99bc 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -96,9 +96,11 @@ class VMOps(object): # write network info admin_context = context.get_admin_context() - network = db.network_get_by_instance(admin_context, - instance['id']) - for network in db.network_get_all(admin_context): + #network = db.network_get_by_instance(admin_context, + # instance['id']) + + for network in db.network_get_all_by_instance(admin_context, + instance['id']): mac_id = instance.mac_address.replace(':', '') location = 'vm-data/networking/%s' % mac_id mapping = {'label': network['label'], @@ -119,6 +121,7 @@ class VMOps(object): network_ref, instance.mac_address) # call reset networking + self.reset_network(vm_ref) LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) @@ -389,7 +392,7 @@ class VMOps(object): # TODO: implement this! return 'http://fakeajaxconsole/fake_url' - def reset_networking(self, instance): + def reset_network(self, instance): vm = self._get_vm_opaque_ref(instance) args = {'id': str(uuid.uuid4())} resp = self._make_agent_call('resetnetwork', vm, '', args) -- cgit From e59c62efe5492e59fcc26b7b74f6ac2daa0caabe Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 7 Feb 2011 16:57:02 -0600 Subject: Added data_transfer xapi plugin --- nova/virt/xenapi_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 628291764..acfde6caf 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -193,7 +193,7 @@ class XenAPIConnection(object): self._vmops.power_on(instance) def transfer_disk(self, instance, dest, callback): - self._vmops.transfer_disk( + self._vmops.transfer_disk() def suspend(self, instance, callback): """suspend the specified instance""" -- cgit From bb2a379e2827ceccc5b46b0a9936e6dcedc6499e Mon Sep 17 00:00:00 2001 From: Ken Pepple Date: Mon, 7 Feb 2011 15:04:26 -0800 Subject: added INSTANCE_TYPES to test for compatibility with current tests --- nova/virt/libvirt_conn.py | 7 +++---- nova/virt/xenapi/vm_utils.py | 4 ++-- 2 files changed, 5 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e66115464..94fe93c40 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -55,6 +55,7 @@ from nova import db from nova import exception from nova import flags from nova import log as logging +from nova import test from nova import utils #from nova.api import context from nova.auth import manager @@ -611,8 +612,7 @@ class LibvirtConnection(object): user=user, project=project, size=size) - # FIXME(kpepple) for dynamic flavors - type_data = instance_types.INSTANCE_TYPES[inst['instance_type']] + type_data = test.INSTANCE_TYPES[inst['instance_type']] if type_data['local_gb']: self._cache_image(fn=self._create_local, @@ -672,9 +672,8 @@ class LibvirtConnection(object): network = db.network_get_by_instance(context.get_admin_context(), instance['id']) # FIXME(vish): stick this in db - # FIXME(kpepple) for dynamic flavors instance_type = instance['instance_type'] - instance_type = instance_types.INSTANCE_TYPES[instance_type] + instance_type = test.INSTANCE_TYPES[instance_type] ip_address = db.instance_get_fixed_address(context.get_admin_context(), instance['id']) # Assume that the gateway also acts as the dhcp server. diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 3f0112609..38a6f73ce 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -31,6 +31,7 @@ import glance.client from nova import exception from nova import flags from nova import log as logging +from nova import test from nova import utils from nova.auth.manager import AuthManager from nova.compute import instance_types @@ -82,8 +83,7 @@ class VMHelper(HelperBase): the pv_kernel flag indicates whether the guest is HVM or PV """ - # FIXME(kpepple) for dynamic flavors - instance_type = instance_types.INSTANCE_TYPES[instance.instance_type] + instance_type = test.INSTANCE_TYPES[instance.instance_type] mem = str(long(instance_type['memory_mb']) * 1024 * 1024) vcpus = str(instance_type['vcpus']) rec = { -- cgit From a40f6041556ec09a1cb79c2b8abcec7fa70e72bf Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 7 Feb 2011 17:12:15 -0600 Subject: Some stuff --- nova/virt/xenapi_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index acfde6caf..726106b37 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -193,7 +193,7 @@ class XenAPIConnection(object): self._vmops.power_on(instance) def transfer_disk(self, instance, dest, callback): - self._vmops.transfer_disk() + self._vmops.transfer_disk(dest) def suspend(self, instance, callback): """suspend the specified instance""" -- cgit From 203c94c89caabc1d4ece4c462819a90c05cde163 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 7 Feb 2011 17:39:53 -0600 Subject: blargh --- nova/virt/xenapi/vmops.py | 8 ++++++++ nova/virt/xenapi_conn.py | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 468881355..4b835c707 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -220,6 +220,14 @@ class VMOps(object): logging.debug(_("Finished snapshot and upload for VM %s"), instance) + def transfer_disk(self, instance, dest): + """ Copies a VHD from one host machine to another + + :param instance: the instance that owns the VHD in question + :param dest: the destination host machine + """ + + def resize(self, instance, flavor): """Resize a running instance by changing it's RAM and disk size """ raise NotImplementedError() diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 726106b37..2e587117a 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -193,7 +193,7 @@ class XenAPIConnection(object): self._vmops.power_on(instance) def transfer_disk(self, instance, dest, callback): - self._vmops.transfer_disk(dest) + self._vmops.transfer_disk(instance, dest) def suspend(self, instance, callback): """suspend the specified instance""" -- cgit From 3f2cd17011e17991ebf1a77605686ce3dc48d92e Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 8 Feb 2011 10:47:23 -0600 Subject: Changes and bug fixes --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 4b835c707..6a7621502 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -226,7 +226,7 @@ class VMOps(object): :param instance: the instance that owns the VHD in question :param dest: the destination host machine """ - + vm_ref = VMHelper.lookup(self._session, instance.name) def resize(self, instance, flavor): """Resize a running instance by changing it's RAM and disk size """ -- cgit From ce5e3bdd30712aa6704926e6cdeb5ae73ae8200b Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 9 Feb 2011 15:26:37 -0600 Subject: A lot of stuff --- nova/virt/xenapi/vmops.py | 53 +++++++++++++++++++++++++++++++++++++---------- nova/virt/xenapi_conn.py | 8 ++++++- 2 files changed, 49 insertions(+), 12 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6a7621502..40b075b3d 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -196,6 +196,26 @@ class VMOps(object): Glance. """ + with self._get_snapshot(instance) as snapshot: + # call plugin to ship snapshot off to glance + VMHelper.upload_image( + self._session, instance.id, snapshot.vdi_uuids, image_id) + + logging.debug(_("Finished snapshot and upload for VM %s"), instance) + + def _get_snapshot(self, instance): + class Snapshot(object): + def __init__(self, virt, instance, vdis): + self.instance = instance + self.vdi_uuids = vdis + self.virt = virt + + def __enter__(self): + return self + + def __exit__(self, type, value, traceback): + self.virt._destroy(self.instance, self.vm_ref, shutdown=False) + #TODO(sirp): Add quiesce and VSS locking support when Windows support # is added @@ -204,30 +224,41 @@ class VMOps(object): label = "%s-snapshot" % instance.name try: - template_vm_ref, template_vdi_uuids = VMHelper.create_snapshot( + _, template_vdi_uuids = VMHelper.create_snapshot( self._session, instance.id, vm_ref, label) + return Snapshot(self, instance, template_vdi_uuids) except self.XenAPI.Failure, exc: logging.error(_("Unable to Snapshot %(vm_ref)s: %(exc)s") % locals()) return - try: - # call plugin to ship snapshot off to glance - VMHelper.upload_image( - self._session, instance.id, template_vdi_uuids, image_id) - finally: - self._destroy(instance, template_vm_ref, shutdown=False) - - logging.debug(_("Finished snapshot and upload for VM %s"), instance) - - def transfer_disk(self, instance, dest): + def migrate_disk_and_power_off(self, instance, dest): """ Copies a VHD from one host machine to another :param instance: the instance that owns the VHD in question :param dest: the destination host machine + :param disk_type: values are 'primary' or 'cow' """ vm_ref = VMHelper.lookup(self._session, instance.name) + # The primary VDI becomes the COW after the snapshot. We can figure + # this out from the VBD. The base copy is the parent_uuid returned + # from the snapshot creation + with self._get_snapshot(instance) as snapshot: + params = {'host':dest, 'vdi_uuid':snapshot.vdi_uuids[1]} + kwargs = {'params': pickle.dumps(params)} + self._session.async_call_plugin('data_transfer', 'transfer_vhd', + kwargs) + + # Now power down the instance and transfer the COW VHD + self._shutdown(instance, method='clean') + + _, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) + params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid']} + kwargs = {'params': pickle.dumps(params)} + self._session.async_call_plugin('data_transfer', 'transfer_vhd', + kwargs) + def resize(self, instance, flavor): """Resize a running instance by changing it's RAM and disk size """ raise NotImplementedError() diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 2e587117a..98b5e7851 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -192,8 +192,14 @@ class XenAPIConnection(object): """powers on a powered off VM instance""" self._vmops.power_on(instance) - def transfer_disk(self, instance, dest, callback): + def migrate_disk_and_power_off(self, instance, dest): + """Transfers the VHD of a running instance to another host, then shuts + off the instance copies over the COW disk""" self._vmops.transfer_disk(instance, dest) + + def move_disk(self, instance_ref): + """Moves the copied VDIs into the SR""" + pass def suspend(self, instance, callback): """suspend the specified instance""" -- cgit From cf2db4f18dbff14fb8882a4747c607ff26b1de55 Mon Sep 17 00:00:00 2001 From: Ken Pepple Date: Wed, 9 Feb 2011 13:58:43 -0800 Subject: fixed overlooked mandatory changes in Xen --- nova/virt/libvirt_conn.py | 5 +++-- nova/virt/xenapi/vm_utils.py | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 94fe93c40..14cc4cf39 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -612,7 +612,7 @@ class LibvirtConnection(object): user=user, project=project, size=size) - type_data = test.INSTANCE_TYPES[inst['instance_type']] + type_data = instance_types.get_instance_type([inst['instance_type']]) if type_data['local_gb']: self._cache_image(fn=self._create_local, @@ -673,7 +673,8 @@ class LibvirtConnection(object): instance['id']) # FIXME(vish): stick this in db instance_type = instance['instance_type'] - instance_type = test.INSTANCE_TYPES[instance_type] + # instance_type = test.INSTANCE_TYPES[instance_type] + instance_type = instance_types.get_instance_type(instance_type) ip_address = db.instance_get_fixed_address(context.get_admin_context(), instance['id']) # Assume that the gateway also acts as the dhcp server. diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 38a6f73ce..a9308eea1 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -31,7 +31,6 @@ import glance.client from nova import exception from nova import flags from nova import log as logging -from nova import test from nova import utils from nova.auth.manager import AuthManager from nova.compute import instance_types @@ -83,7 +82,8 @@ class VMHelper(HelperBase): the pv_kernel flag indicates whether the guest is HVM or PV """ - instance_type = test.INSTANCE_TYPES[instance.instance_type] + instance_type = instance_types.\ + get_instance_type(instance.instance_type) mem = str(long(instance_type['memory_mb']) * 1024 * 1024) vcpus = str(instance_type['vcpus']) rec = { -- cgit From ac33f61c5c382fc7c8e8ab872192858860672d70 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 9 Feb 2011 16:38:27 -0600 Subject: Plugin tidying and more migration implementation --- nova/virt/xenapi/vm_utils.py | 16 +++++++++------- nova/virt/xenapi/vmops.py | 35 +++++++++++++++++++++++++---------- nova/virt/xenapi_conn.py | 9 ++++++--- 3 files changed, 40 insertions(+), 20 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 4bbd522c1..e16662aad 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -478,6 +478,14 @@ class VMHelper(HelperBase): except cls.XenAPI.Failure as e: return {"Unable to retrieve diagnostics": e} + @classmethod + def scan_sr(cls, session, instance_id, sr_ref): + LOG.debug(_("Re-scanning SR %s"), sr_ref) + task = session.call_xenapi('Async.SR.scan', sr_ref) + session.wait_for_task(instance_id, task) + + + def get_rrd(host, uuid): """Return the VM RRD XML as a string""" @@ -520,12 +528,6 @@ def get_vhd_parent_uuid(session, vdi_ref): return None -def scan_sr(session, instance_id, sr_ref): - LOG.debug(_("Re-scanning SR %s"), sr_ref) - task = session.call_xenapi('Async.SR.scan', sr_ref) - session.wait_for_task(instance_id, task) - - def wait_for_vhd_coalesce(session, instance_id, sr_ref, vdi_ref, original_parent_uuid): """ Spin until the parent VHD is coalesced into its parent VHD @@ -550,7 +552,7 @@ def wait_for_vhd_coalesce(session, instance_id, sr_ref, vdi_ref, " %(max_attempts)d), giving up...") % locals()) raise exception.Error(msg) - scan_sr(session, instance_id, sr_ref) + VMHelper.scan_sr(session, instance_id, sr_ref) parent_uuid = get_vhd_parent_uuid(session, vdi_ref) if original_parent_uuid and (parent_uuid != original_parent_uuid): LOG.debug(_("Parent %(parent_uuid)s doesn't match original parent" diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 40b075b3d..ea4b7899b 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -146,7 +146,7 @@ class VMOps(object): """ vm = None try: - if instance_or_vm.startswith("OpaqueRef:"): + if instance_or_vm.startswith("OpaqueRef:") # Got passed an opaque ref; return it return instance_or_vm else: @@ -241,23 +241,38 @@ class VMOps(object): """ vm_ref = VMHelper.lookup(self._session, instance.name) - # The primary VDI becomes the COW after the snapshot. We can figure - # this out from the VBD. The base copy is the parent_uuid returned + # The primary VDI becomes the COW after the snapshot, and we can + # identify it via the VBD. The base copy is the parent_uuid returned # from the snapshot creation + + #TODO(mdietz): explicitly forcing the base_copy and cow names is + #pretty fugly with self._get_snapshot(instance) as snapshot: - params = {'host':dest, 'vdi_uuid':snapshot.vdi_uuids[1]} - kwargs = {'params': pickle.dumps(params)} - self._session.async_call_plugin('data_transfer', 'transfer_vhd', - kwargs) + params = {'host':dest, 'vdi_uuid':snapshot.vdi_uuids[1], + 'dest_name':'base_copy.vhd'} + self._session.async_call_plugin('migration', 'transfer_vhd', + {'params': pickle.dumps(params)}) # Now power down the instance and transfer the COW VHD self._shutdown(instance, method='clean') _, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) - params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid']} - kwargs = {'params': pickle.dumps(params)} + params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], + 'dest_name': 'cow.vhd'} self._session.async_call_plugin('data_transfer', 'transfer_vhd', - kwargs) + {'params': pickle.dumps(params)}) + return snapshot.vdi_uuids[1], vm_vdi_rec['uuid'] + + def attach_disk(self, instance): + vm_ref = VMHelper.lookup(self._session, instance.name) + + params = { 'instance_id': instance.id } + self._session.async_call_plugin('migration', 'move_vhds_into_sr', + {'params': pickle.dumps(params)}) + + + _, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) + VMHelper.scan_sr(self._session, instance.id, vm_vdi_rec['SR']) def resize(self, instance, flavor): """Resize a running instance by changing it's RAM and disk size """ diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 98b5e7851..cc43050b4 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -164,6 +164,9 @@ class XenAPIConnection(object): """Resize a VM instance""" raise NotImplementedError() + def attach_disk(self, instance_ref): + + def reboot(self, instance): """Reboot VM instance""" self._vmops.reboot(instance) @@ -195,11 +198,11 @@ class XenAPIConnection(object): def migrate_disk_and_power_off(self, instance, dest): """Transfers the VHD of a running instance to another host, then shuts off the instance copies over the COW disk""" - self._vmops.transfer_disk(instance, dest) + self._vmops.migrate_disk_and_power_off(instance, dest) - def move_disk(self, instance_ref): + def attach_disk(self, instance): """Moves the copied VDIs into the SR""" - pass + self._vmops.attach_disk(instance) def suspend(self, instance, callback): """suspend the specified instance""" -- cgit From d8a7a76cd4fd22a6ad9fc1a7b879a8dbffcede5f Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 10 Feb 2011 13:42:57 -0600 Subject: Some more cleanup --- nova/virt/xenapi/vmops.py | 3 ++- nova/virt/xenapi_conn.py | 5 +---- 2 files changed, 3 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ea4b7899b..7d88876e4 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -106,7 +106,8 @@ class VMOps(object): instance.ramdisk_id, user, project, ImageType.KERNEL_RAMDISK) vm_ref = VMHelper.create_vm(self._session, instance, kernel, ramdisk, pv_kernel) - VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) + VMHelper.create_vbd(session=self._session, vm_ref=vm_ref, vdi_ref=vdi_ref, + userdevice=0, bootable=True) if network_ref: VMHelper.create_vif(self._session, vm_ref, diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index cc43050b4..8c756a7e3 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -152,7 +152,7 @@ class XenAPIConnection(object): """List VM instances""" return self._vmops.list_instances() - def spawn(self, instance): + def spawn(self, instance, disk_info=None): """Create VM instance""" self._vmops.spawn(instance) @@ -164,9 +164,6 @@ class XenAPIConnection(object): """Resize a VM instance""" raise NotImplementedError() - def attach_disk(self, instance_ref): - - def reboot(self, instance): """Reboot VM instance""" self._vmops.reboot(instance) -- cgit From a6ce3b777221690df17137e70d6b7bf35ad10b02 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 10 Feb 2011 13:59:54 -0600 Subject: Spawn from disk --- nova/virt/xenapi/vmops.py | 47 ++++++++++++++++++++++++++--------------------- nova/virt/xenapi_conn.py | 4 ++-- 2 files changed, 28 insertions(+), 23 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 7d88876e4..ad46bb40d 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -69,7 +69,7 @@ class VMOps(object): LOG.debug(_("Starting instance %s"), instance.name) self._session.call_xenapi('VM.start', vm, False, False) - def spawn(self, instance): + def spawn(self, instance, disk): """Create VM instance""" vm = VMHelper.lookup(self._session, instance.name) if vm is not None: @@ -83,27 +83,32 @@ class VMOps(object): user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) - #if kernel is not present we must download a raw disk - if instance.kernel_id: - disk_image_type = ImageType.DISK + + vdi_ref = kernel = ramdisk = pv_kernel = None + + # Are we building from a pre-existing disk? + if not disk: + #if kernel is not present we must download a raw disk + if instance.kernel_id: + disk_image_type = ImageType.DISK + else: + disk_image_type = ImageType.DISK_RAW + vdi_uuid = VMHelper.fetch_image(self._session, instance.id, + instance.image_id, user, project, disk_image_type) + vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) + #Have a look at the VDI and see if it has a PV kernel + if not instance.kernel_id: + pv_kernel = VMHelper.lookup_image(self._session, instance.id, + vdi_ref) + if instance.kernel_id: + kernel = VMHelper.fetch_image(self._session, instance.id, + instance.kernel_id, user, project, ImageType.KERNEL_RAMDISK) + if instance.ramdisk_id: + ramdisk = VMHelper.fetch_image(self._session, instance.id, + instance.ramdisk_id, user, project, ImageType.KERNEL_RAMDISK) else: - disk_image_type = ImageType.DISK_RAW - vdi_uuid = VMHelper.fetch_image(self._session, instance.id, - instance.image_id, user, project, disk_image_type) - vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - #Have a look at the VDI and see if it has a PV kernel - pv_kernel = False - if not instance.kernel_id: - pv_kernel = VMHelper.lookup_image(self._session, instance.id, - vdi_ref) - kernel = None - if instance.kernel_id: - kernel = VMHelper.fetch_image(self._session, instance.id, - instance.kernel_id, user, project, ImageType.KERNEL_RAMDISK) - ramdisk = None - if instance.ramdisk_id: - ramdisk = VMHelper.fetch_image(self._session, instance.id, - instance.ramdisk_id, user, project, ImageType.KERNEL_RAMDISK) + vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', disk) + vm_ref = VMHelper.create_vm(self._session, instance, kernel, ramdisk, pv_kernel) VMHelper.create_vbd(session=self._session, vm_ref=vm_ref, vdi_ref=vdi_ref, diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 8c756a7e3..2fddb8c7f 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -152,9 +152,9 @@ class XenAPIConnection(object): """List VM instances""" return self._vmops.list_instances() - def spawn(self, instance, disk_info=None): + def spawn(self, instance, disk=None): """Create VM instance""" - self._vmops.spawn(instance) + self._vmops.spawn(instance, disk) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From 87d0b5203610f1e0a7a2e09033c79071fabacaba Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 10 Feb 2011 15:01:31 -0600 Subject: passing instance to reset_network instead of vm_ref, also not converting to an opaque ref before making plugin call --- nova/virt/xenapi/vmops.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 4056e99bc..575e53f80 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -121,7 +121,7 @@ class VMOps(object): network_ref, instance.mac_address) # call reset networking - self.reset_network(vm_ref) + self.reset_network(instance) LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) @@ -393,9 +393,8 @@ class VMOps(object): return 'http://fakeajaxconsole/fake_url' def reset_network(self, instance): - vm = self._get_vm_opaque_ref(instance) args = {'id': str(uuid.uuid4())} - resp = self._make_agent_call('resetnetwork', vm, '', args) + resp = self._make_agent_call('resetnetwork', instance, '', args) def list_from_xenstore(self, vm, path): """Runs the xenstore-ls command to get a listing of all records -- cgit From a70ac6609713f2b610923a7ae382208f4d46b74a Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 10 Feb 2011 15:01:38 -0600 Subject: Typo fixes and some stupidity about the models --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ad46bb40d..3b14390b4 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -152,7 +152,7 @@ class VMOps(object): """ vm = None try: - if instance_or_vm.startswith("OpaqueRef:") + if instance_or_vm.startswith("OpaqueRef:"): # Got passed an opaque ref; return it return instance_or_vm else: -- cgit From a36b67d192eb619963494896928efffef5dae4b6 Mon Sep 17 00:00:00 2001 From: Ken Pepple Date: Thu, 10 Feb 2011 18:35:10 -0800 Subject: after hours of tracking his prey, ken slowly crept behind the elusive wilderbeast test import hiding in the libvirt_conn.py bushes and gutted it with his steely blade --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 14cc4cf39..35b78368e 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -55,7 +55,7 @@ from nova import db from nova import exception from nova import flags from nova import log as logging -from nova import test +#from nova import test from nova import utils #from nova.api import context from nova.auth import manager -- cgit From 9c0862b5f84cdb09b7ab0aafca669d30f261a666 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 14 Feb 2011 10:21:16 -0600 Subject: support for multiple IPs per network --- nova/virt/xenapi/vmops.py | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 575e53f80..db05a24ff 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -96,22 +96,36 @@ class VMOps(object): # write network info admin_context = context.get_admin_context() - #network = db.network_get_by_instance(admin_context, - # instance['id']) + # TODO(tr3buchet) - remove comment in multi-nic + # I've decided to go ahead and consider multiple IPs and networks + # at this stage even though they aren't implemented because these will + # be needed for multi-nic and there was no sense writing it for single + # network/single IP and then having to turn around and re-write it + IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) for network in db.network_get_all_by_instance(admin_context, instance['id']): + network_IPs = [ip for ip in IPs if ip.network_id == network.id] + + def ip_dict(ip): + return {'netmask': network['netmask'], + 'enabled': '1', + 'ip': ip.address} + mac_id = instance.mac_address.replace(':', '') location = 'vm-data/networking/%s' % mac_id mapping = {'label': network['label'], 'gateway': network['gateway'], 'mac': instance.mac_address, 'dns': [network['dns']], - 'ips': [{'netmask': network['netmask'], - 'enabled': '1', - 'ip': '192.168.3.3'}]} # <===== CHANGE!!!! + 'ips': [ip_dict(ip) for ip in network_IPs]} self.write_to_param_xenstore(vm_ref, {location: mapping}) + # TODO(tr3buchet) - remove comment in multi-nic + # this bit here about creating the vifs will be updated + # in multi-nic to handle multiple IPs on the same network + # and multiple networks + # for now it works as there is only one of each bridge = network['bridge'] network_ref = \ NetworkHelper.find_network_with_bridge(self._session, bridge) -- cgit From 3f96e6dbf12533355aa6722eeb498814df076aea Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 14 Feb 2011 12:32:33 -0600 Subject: added call to reset_network from openstack api down to vmops --- nova/virt/xenapi_conn.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 927f5905b..4e5442aa6 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -188,6 +188,10 @@ class XenAPIConnection(object): """resume the specified instance""" self._vmops.resume(instance, callback) + def reset_network(self, instance): + """reset networking for specified instance""" + self._vmops.reset_network(instance) + def get_info(self, instance_id): """Return data about VM instance""" return self._vmops.get_info(instance_id) -- cgit From 1631196f3f277608fb0569c7242a7d8391605d0d Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 13:38:05 -0600 Subject: wharrgarbl --- nova/virt/xenapi/vmops.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3b14390b4..d5b2c821c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -230,7 +230,7 @@ class VMOps(object): label = "%s-snapshot" % instance.name try: - _, template_vdi_uuids = VMHelper.create_snapshot( + vdi_ref, template_vdi_uuids = VMHelper.create_snapshot( self._session, instance.id, vm_ref, label) return Snapshot(self, instance, template_vdi_uuids) except self.XenAPI.Failure, exc: @@ -262,22 +262,21 @@ class VMOps(object): # Now power down the instance and transfer the COW VHD self._shutdown(instance, method='clean') - _, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) + vdi_ref, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], 'dest_name': 'cow.vhd'} self._session.async_call_plugin('data_transfer', 'transfer_vhd', {'params': pickle.dumps(params)}) return snapshot.vdi_uuids[1], vm_vdi_rec['uuid'] - def attach_disk(self, instance): + def attach_disk(self, instance):hh vm_ref = VMHelper.lookup(self._session, instance.name) params = { 'instance_id': instance.id } self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) - - _, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) + vdi_ref, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) VMHelper.scan_sr(self._session, instance.id, vm_vdi_rec['SR']) def resize(self, instance, flavor): -- cgit From 9f22390532332b955cb8d78ebfd8cf9670a63ac8 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 13:50:06 -0600 Subject: Snapshot correctly --- nova/virt/xenapi/vmops.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index d5b2c821c..fc5cd84e1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -211,10 +211,11 @@ class VMOps(object): def _get_snapshot(self, instance): class Snapshot(object): - def __init__(self, virt, instance, vdis): + def __init__(self, virt, instance, vm_ref, vdis): self.instance = instance self.vdi_uuids = vdis self.virt = virt + self.vm_ref = vm_ref def __enter__(self): return self @@ -230,9 +231,10 @@ class VMOps(object): label = "%s-snapshot" % instance.name try: - vdi_ref, template_vdi_uuids = VMHelper.create_snapshot( + template_vm_ref, template_vdi_uuids = VMHelper.create_snapshot( self._session, instance.id, vm_ref, label) - return Snapshot(self, instance, template_vdi_uuids) + return Snapshot(self, instance, template_vm_ref, + template_vdi_uuids) except self.XenAPI.Failure, exc: logging.error(_("Unable to Snapshot %(vm_ref)s: %(exc)s") % locals()) @@ -269,7 +271,7 @@ class VMOps(object): {'params': pickle.dumps(params)}) return snapshot.vdi_uuids[1], vm_vdi_rec['uuid'] - def attach_disk(self, instance):hh + def attach_disk(self, instance): vm_ref = VMHelper.lookup(self._session, instance.name) params = { 'instance_id': instance.id } -- cgit From fc8394a80b28f94561aa9ebf94c067ce2d1efd3b Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 14:25:00 -0600 Subject: Snapshot correctly --- nova/virt/xenapi/vmops.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index fc5cd84e1..a327f1d36 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -22,6 +22,7 @@ Management class for VM-related functions (spawn, reboot, etc). import json import M2Crypto import os +import pickle import subprocess import tempfile import uuid @@ -262,7 +263,7 @@ class VMOps(object): {'params': pickle.dumps(params)}) # Now power down the instance and transfer the COW VHD - self._shutdown(instance, method='clean') + self._shutdown(instance, snapshot.vm_ref, method='clean') vdi_ref, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], -- cgit From 411d828fc3511a09420e579ceee65a9470242509 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 14:40:58 -0600 Subject: hurr --- nova/virt/xenapi/vm_utils.py | 38 +++++++++++++++++++++----------------- nova/virt/xenapi/vmops.py | 8 +++++--- 2 files changed, 26 insertions(+), 20 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index e16662aad..2c4ae6aa2 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -238,6 +238,24 @@ class VMHelper(HelperBase): % locals()) return vdi_ref + @classmethod + def get_vdi_for_vm_safely(cls, session, vm_ref): + vdi_refs = VMHelper.lookup_vm_vdis(session, vm_ref) + if vdi_refs is None: + raise Exception(_("No VDIs found for VM %s") % vm_ref) + else: + num_vdis = len(vdi_refs) + if num_vdis != 1: + raise Exception(_("Unexpected number of VDIs (%(num_vdis)s) found" + " for VM %(vm_ref)s") % locals()) + + vdi_ref = vdi_refs[0] + vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref) + return vdi_ref, vdi_rec + + + + @classmethod def create_snapshot(cls, session, instance_id, vm_ref, label): """ Creates Snapshot (Template) VM, Snapshot VBD, Snapshot VDI, @@ -248,7 +266,7 @@ class VMHelper(HelperBase): LOG.debug(_("Snapshotting VM %(vm_ref)s with label '%(label)s'...") % locals()) - vm_vdi_ref, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) + vm_vdi_ref, vm_vdi_rec = self.get_vdi_for_vm_safely(session, vm_ref) vm_vdi_uuid = vm_vdi_rec["uuid"] sr_ref = vm_vdi_rec["SR"] @@ -256,7 +274,8 @@ class VMHelper(HelperBase): task = session.call_xenapi('Async.VM.snapshot', vm_ref, label) template_vm_ref = session.wait_for_task(instance_id, task) - template_vdi_rec = get_vdi_for_vm_safely(session, template_vm_ref)[1] + template_vdi_rec = self.get_vdi_for_vm_safely(session, + template_vm_ref)[1] template_vdi_uuid = template_vdi_rec["uuid"] LOG.debug(_('Created snapshot %(template_vm_ref)s from' @@ -568,21 +587,6 @@ def wait_for_vhd_coalesce(session, instance_id, sr_ref, vdi_ref, return parent_uuid -def get_vdi_for_vm_safely(session, vm_ref): - vdi_refs = VMHelper.lookup_vm_vdis(session, vm_ref) - if vdi_refs is None: - raise Exception(_("No VDIs found for VM %s") % vm_ref) - else: - num_vdis = len(vdi_refs) - if num_vdis != 1: - raise Exception(_("Unexpected number of VDIs (%(num_vdis)s) found" - " for VM %(vm_ref)s") % locals()) - - vdi_ref = vdi_refs[0] - vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref) - return vdi_ref, vdi_rec - - def find_sr(session): host = session.get_xenapi_host() srs = session.get_xenapi().SR.get_all() diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a327f1d36..6a7308c74 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -263,9 +263,10 @@ class VMOps(object): {'params': pickle.dumps(params)}) # Now power down the instance and transfer the COW VHD - self._shutdown(instance, snapshot.vm_ref, method='clean') + self._shutdown(instance, vm_ref, method='clean') - vdi_ref, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) + vdi_ref, vm_vdi_rec = \ + VMHelper.get_vdi_for_vm_safely(session, vm_ref) params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], 'dest_name': 'cow.vhd'} self._session.async_call_plugin('data_transfer', 'transfer_vhd', @@ -279,7 +280,8 @@ class VMOps(object): self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) - vdi_ref, vm_vdi_rec = get_vdi_for_vm_safely(session, vm_ref) + vdi_ref, vm_vdi_rec = \ + VMHelper.get_vdi_for_vm_safely(session, vm_ref) VMHelper.scan_sr(self._session, instance.id, vm_vdi_rec['SR']) def resize(self, instance, flavor): -- cgit From 7bb6122549ad5ac549465f0012020f8e5dc9d506 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 15:26:08 -0600 Subject: Some refactoring --- nova/virt/xenapi/vm_utils.py | 12 ++++++++---- nova/virt/xenapi/vmops.py | 13 ++++++++----- nova/virt/xenapi_conn.py | 2 +- 3 files changed, 17 insertions(+), 10 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 2c4ae6aa2..eeb5502ed 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -266,7 +266,7 @@ class VMHelper(HelperBase): LOG.debug(_("Snapshotting VM %(vm_ref)s with label '%(label)s'...") % locals()) - vm_vdi_ref, vm_vdi_rec = self.get_vdi_for_vm_safely(session, vm_ref) + vm_vdi_ref, vm_vdi_rec = cls.get_vdi_for_vm_safely(session, vm_ref) vm_vdi_uuid = vm_vdi_rec["uuid"] sr_ref = vm_vdi_rec["SR"] @@ -274,7 +274,7 @@ class VMHelper(HelperBase): task = session.call_xenapi('Async.VM.snapshot', vm_ref, label) template_vm_ref = session.wait_for_task(instance_id, task) - template_vdi_rec = self.get_vdi_for_vm_safely(session, + template_vdi_rec = cls.get_vdi_for_vm_safely(session, template_vm_ref)[1] template_vdi_uuid = template_vdi_rec["uuid"] @@ -287,6 +287,12 @@ class VMHelper(HelperBase): #TODO(sirp): we need to assert only one parent, not parents two deep return template_vm_ref, [template_vdi_uuid, parent_uuid] + @classmethod + def get_sr(cls, session, sr_label='slices'): + """ Finds the SR named by the given name label and returns + the UUID """ + return session.call_xenapi('SR.get_by_name_label', sr_label)[0] + @classmethod def upload_image(cls, session, instance_id, vdi_uuids, image_id): """ Requests that the Glance plugin bundle the specified VDIs and @@ -504,8 +510,6 @@ class VMHelper(HelperBase): session.wait_for_task(instance_id, task) - - def get_rrd(host, uuid): """Return the VM RRD XML as a string""" try: diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6a7308c74..470b6ea8c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -266,7 +266,7 @@ class VMOps(object): self._shutdown(instance, vm_ref, method='clean') vdi_ref, vm_vdi_rec = \ - VMHelper.get_vdi_for_vm_safely(session, vm_ref) + VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], 'dest_name': 'cow.vhd'} self._session.async_call_plugin('data_transfer', 'transfer_vhd', @@ -277,12 +277,15 @@ class VMOps(object): vm_ref = VMHelper.lookup(self._session, instance.name) params = { 'instance_id': instance.id } - self._session.async_call_plugin('migration', 'move_vhds_into_sr', + new_base_copy_uuid, new_cow_uuid = self._session.async_call_plugin( + 'migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) - vdi_ref, vm_vdi_rec = \ - VMHelper.get_vdi_for_vm_safely(session, vm_ref) - VMHelper.scan_sr(self._session, instance.id, vm_vdi_rec['SR']) + # Now we rescan the SR so we find the VHDs + sr_ref = VMHelper.get_sr(self._session) + VMHelper.scan_sr(self._session, instance.id, sr_ref) + + return new_base_copy_uuid def resize(self, instance, flavor): """Resize a running instance by changing it's RAM and disk size """ diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 2fddb8c7f..6869ce8d8 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -199,7 +199,7 @@ class XenAPIConnection(object): def attach_disk(self, instance): """Moves the copied VDIs into the SR""" - self._vmops.attach_disk(instance) + return self._vmops.attach_disk(instance) def suspend(self, instance, callback): """suspend the specified instance""" -- cgit From fad5baf307b74a92fd5b9d8e2d1479f558e180aa Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 15:55:52 -0600 Subject: hurr --- nova/virt/xenapi/vm_utils.py | 12 ++++++++---- nova/virt/xenapi/vmops.py | 13 ++++++++----- 2 files changed, 16 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index eeb5502ed..23f9547d7 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -504,10 +504,14 @@ class VMHelper(HelperBase): return {"Unable to retrieve diagnostics": e} @classmethod - def scan_sr(cls, session, instance_id, sr_ref): - LOG.debug(_("Re-scanning SR %s"), sr_ref) - task = session.call_xenapi('Async.SR.scan', sr_ref) - session.wait_for_task(instance_id, task) + def scan_sr(cls, session, instance_id=None, sr_ref=None): + if sr_ref: + LOG.debug(_("Re-scanning SR %s"), sr_ref) + task = session.call_xenapi('Async.SR.scan', sr_ref) + session.wait_for_task(instance_id, task) + else: + sr_ref = cls.get_sr(session) + session.call_xen_api('SR.scan', sr_ref) def get_rrd(host, uuid): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 470b6ea8c..17d42d542 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -276,14 +276,17 @@ class VMOps(object): def attach_disk(self, instance): vm_ref = VMHelper.lookup(self._session, instance.name) - params = { 'instance_id': instance.id } - new_base_copy_uuid, new_cow_uuid = self._session.async_call_plugin( - 'migration', 'move_vhds_into_sr', + new_base_copy_uuid = str(uuid.uuid4()) + + params = { 'instance_id': instance.id, + 'new_base_copy_uuid': new_base_copy_uuid, + 'new_cow_uuid': str(uuid.uuid4() } + + self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) # Now we rescan the SR so we find the VHDs - sr_ref = VMHelper.get_sr(self._session) - VMHelper.scan_sr(self._session, instance.id, sr_ref) + VMHelper.scan_sr(self._session) return new_base_copy_uuid -- cgit From 9a71c79dc3beb554c86a1b1b5d03ab66c6e96edc Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 16:24:51 -0600 Subject: Typo fixes --- nova/virt/xenapi/vm_utils.py | 2 +- nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 23f9547d7..08064b786 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -511,7 +511,7 @@ class VMHelper(HelperBase): session.wait_for_task(instance_id, task) else: sr_ref = cls.get_sr(session) - session.call_xen_api('SR.scan', sr_ref) + session.call_xenapi('SR.scan', sr_ref) def get_rrd(host, uuid): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 17d42d542..6c6d04dbf 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -280,7 +280,7 @@ class VMOps(object): params = { 'instance_id': instance.id, 'new_base_copy_uuid': new_base_copy_uuid, - 'new_cow_uuid': str(uuid.uuid4() } + 'new_cow_uuid': str(uuid.uuid4()) } self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) -- cgit From 41e4e18a0324593c0076c3936d63bb6dcca487cb Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Mon, 14 Feb 2011 23:12:34 +0000 Subject: First cut on XenServer unified-images --- nova/virt/xenapi/vm_utils.py | 47 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 43 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 4bbd522c1..6d6067da5 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -266,7 +266,9 @@ class VMHelper(HelperBase): session, instance_id, sr_ref, vm_vdi_ref, original_parent_uuid) #TODO(sirp): we need to assert only one parent, not parents two deep - return template_vm_ref, [template_vdi_uuid, parent_uuid] + template_vdi_uuids = {'image': parent_uuid, + 'snap': template_vdi_uuid} + return template_vm_ref, template_vdi_uuids @classmethod def upload_image(cls, session, instance_id, vdi_uuids, image_id): @@ -303,15 +305,36 @@ class VMHelper(HelperBase): return cls._fetch_image_objectstore(session, instance_id, image, access, user.secret, type) + @classmethod - def _fetch_image_glance(cls, session, instance_id, image, access, type): + def _fetch_image_glance_vhd(cls, session, instance_id, image, access, type): + LOG.debug(_("Asking xapi to fetch vhd image %(image)s") + % locals()) + + sr_ref = find_sr(session) + if sr_ref is None: + raise exception.NotFound('Cannot find SR to write VDI to') + + params = {'image_id': image, + 'glance_host': FLAGS.glance_host, + 'glance_port': FLAGS.glance_port} + + kwargs = {'params': pickle.dumps(params)} + task = session.async_call_plugin('glance', 'get_vdi', kwargs) + vdi_uuid = session.wait_for_task(instance_id, task) + scan_sr(session, instance_id, sr_ref) + LOG.debug(_("Xapi 'get_vdi' returned VDI UUID %(vdi_uuid)s") % locals()) + return vdi_uuid + + @classmethod + def _fetch_image_glance_disk(cls, session, instance_id, image, access, type): sr = find_sr(session) if sr is None: raise exception.NotFound('Cannot find SR to write VDI to') - c = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) + client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) - meta, image_file = c.get_image(image) + meta, image_file = client.get_image(image) virtual_size = int(meta['size']) vdi_size = virtual_size LOG.debug(_("Size for image %(image)s:%(virtual_size)d") % locals()) @@ -344,6 +367,22 @@ class VMHelper(HelperBase): else: return session.get_xenapi().VDI.get_uuid(vdi) + @classmethod + def _fetch_image_glance(cls, session, instance_id, image, access, type): + client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) + meta = client.get_image_meta(image) + properties = meta['properties'] + disk_format = properties.get('disk_format', None) + + # TODO(sirp): When Glance treats disk_format as a first class + # attribute, we should start using that rather than an image-property + if disk_format == 'vhd': + return cls._fetch_image_glance_vhd( + session, instance_id, image, access, type) + else: + return cls._fetch_image_glance_disk( + session, instance_id, image, access, type) + @classmethod def _fetch_image_objectstore(cls, session, instance_id, image, access, secret, type): -- cgit From 0bd48e3d53c6fce04b0c5e483537b3fd31c7364a Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 17:24:33 -0600 Subject: bad plugin --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6c6d04dbf..5ab73d562 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -269,7 +269,7 @@ class VMOps(object): VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], 'dest_name': 'cow.vhd'} - self._session.async_call_plugin('data_transfer', 'transfer_vhd', + self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) return snapshot.vdi_uuids[1], vm_vdi_rec['uuid'] -- cgit From b7cf8f233a585043f0aa85f4d26dc2fb5a6701c7 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 17:34:54 -0600 Subject: bad plugin --- nova/virt/xenapi/vmops.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 5ab73d562..ba0db22f1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -258,7 +258,8 @@ class VMOps(object): #pretty fugly with self._get_snapshot(instance) as snapshot: params = {'host':dest, 'vdi_uuid':snapshot.vdi_uuids[1], - 'dest_name':'base_copy.vhd'} + 'dest_name': 'base_copy.vhd', + 'instance_id': instance.id, } self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) @@ -268,7 +269,8 @@ class VMOps(object): vdi_ref, vm_vdi_rec = \ VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], - 'dest_name': 'cow.vhd'} + 'dest_name': 'cow.vhd', + 'instance_id': instance.id, } self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) return snapshot.vdi_uuids[1], vm_vdi_rec['uuid'] -- cgit From fe6efb38ee30c5a3e532cd19faef0fec063b7446 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 01:37:54 +0000 Subject: Adding DISK_VHD to ImageTypes --- nova/virt/xenapi/vm_utils.py | 38 ++++++++++++++++++++++++++++++-------- nova/virt/xenapi/vmops.py | 22 +++++++++++++++------- 2 files changed, 45 insertions(+), 15 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 6d6067da5..a6312d00c 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -63,11 +63,14 @@ class ImageType: 0 - kernel/ramdisk image (goes on dom0's filesystem) 1 - disk image (local SR, partitioned by objectstore plugin) 2 - raw disk image (local SR, NOT partitioned by plugin) + 3 - vhd disk image (local SR, NOT inspected by XS, PV assumed for + linux, HVM assumed for Windows) """ KERNEL_RAMDISK = 0 DISK = 1 DISK_RAW = 2 + DISK_VHD = 3 class VMHelper(HelperBase): @@ -368,15 +371,34 @@ class VMHelper(HelperBase): return session.get_xenapi().VDI.get_uuid(vdi) @classmethod - def _fetch_image_glance(cls, session, instance_id, image, access, type): - client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) - meta = client.get_image_meta(image) - properties = meta['properties'] - disk_format = properties.get('disk_format', None) + def determine_disk_image_type(cls, instance): + instance_id = instance.id + if instance.kernel_id: + #if kernel is not present we must download a raw disk + LOG.debug(_("Instance %(instance_id)s will use DISK format") % + locals()) + return ImageType.DISK - # TODO(sirp): When Glance treats disk_format as a first class - # attribute, we should start using that rather than an image-property - if disk_format == 'vhd': + if FLAGS.xenapi_image_service == 'glance': + # if using glance, then we could be VHD format + client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) + meta = client.get_image_meta(instance.image_id) + properties = meta['properties'] + disk_format = properties.get('disk_format', None) + # TODO(sirp): When Glance treats disk_format as a first class + # attribute, we should start using that rather than an image-property + if disk_format == 'vhd': + LOG.debug(_("Instance %(instance_id)s will use DISK_VHD format") % + locals()) + return ImageType.DISK_VHD + + LOG.debug(_("Instance %(instance_id)s will use DISK_RAW format") % + locals()) + return ImageType.DISK_RAW + + @classmethod + def _fetch_image_glance(cls, session, instance_id, image, access, type): + if type == ImageType.DISK_VHD: return cls._fetch_image_glance_vhd( session, instance_id, image, access, type) else: diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index e84ce20c4..34ceea358 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -74,27 +74,34 @@ class VMOps(object): user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) - #if kernel is not present we must download a raw disk - if instance.kernel_id: - disk_image_type = ImageType.DISK - else: - disk_image_type = ImageType.DISK_RAW + + disk_image_type = VMHelper.determine_disk_image_type(instance) + vdi_uuid = VMHelper.fetch_image(self._session, instance.id, instance.image_id, user, project, disk_image_type) + vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - #Have a look at the VDI and see if it has a PV kernel + pv_kernel = False - if not instance.kernel_id: + if disk_image_type == ImageType.DISK_RAW: + #Have a look at the VDI and see if it has a PV kernel pv_kernel = VMHelper.lookup_image(self._session, instance.id, vdi_ref) + elif disk_image_type == ImageType.DISK_VHD: + # TODO(sirp): Assuming PV for now; this will need to be + # configurable as Windows will use HVM. + pv_kernel = True + kernel = None if instance.kernel_id: kernel = VMHelper.fetch_image(self._session, instance.id, instance.kernel_id, user, project, ImageType.KERNEL_RAMDISK) + ramdisk = None if instance.ramdisk_id: ramdisk = VMHelper.fetch_image(self._session, instance.id, instance.ramdisk_id, user, project, ImageType.KERNEL_RAMDISK) + vm_ref = VMHelper.create_vm(self._session, instance, kernel, ramdisk, pv_kernel) VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) @@ -102,6 +109,7 @@ class VMOps(object): if network_ref: VMHelper.create_vif(self._session, vm_ref, network_ref, instance.mac_address) + LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) instance_name = instance.name -- cgit From e7fe96453760320ef897b9edfc39e057d565e6c0 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 23:22:37 -0600 Subject: Refactored --- nova/virt/xenapi/vmops.py | 50 ++++++++++++++++++++++++++--------------------- nova/virt/xenapi_conn.py | 2 +- 2 files changed, 29 insertions(+), 23 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ba0db22f1..127a09ad1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -103,17 +103,19 @@ class VMOps(object): vdi_ref) if instance.kernel_id: kernel = VMHelper.fetch_image(self._session, instance.id, - instance.kernel_id, user, project, ImageType.KERNEL_RAMDISK) + instance.kernel_id, user, project, + ImageType.KERNEL_RAMDISK) if instance.ramdisk_id: ramdisk = VMHelper.fetch_image(self._session, instance.id, - instance.ramdisk_id, user, project, ImageType.KERNEL_RAMDISK) + instance.ramdisk_id, user, project, + ImageType.KERNEL_RAMDISK) else: vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', disk) vm_ref = VMHelper.create_vm(self._session, instance, kernel, ramdisk, pv_kernel) - VMHelper.create_vbd(session=self._session, vm_ref=vm_ref, vdi_ref=vdi_ref, - userdevice=0, bootable=True) + VMHelper.create_vbd(session=self._session, vm_ref=vm_ref, + vdi_ref=vdi_ref, userdevice=0, bootable=True) if network_ref: VMHelper.create_vif(self._session, vm_ref, @@ -234,7 +236,7 @@ class VMOps(object): try: template_vm_ref, template_vdi_uuids = VMHelper.create_snapshot( self._session, instance.id, vm_ref, label) - return Snapshot(self, instance, template_vm_ref, + return Snapshot(self, instance, template_vm_ref, template_vdi_uuids) except self.XenAPI.Failure, exc: logging.error(_("Unable to Snapshot %(vm_ref)s: %(exc)s") @@ -254,35 +256,40 @@ class VMOps(object): # identify it via the VBD. The base copy is the parent_uuid returned # from the snapshot creation - #TODO(mdietz): explicitly forcing the base_copy and cow names is - #pretty fugly + base_copy_uuid = cow_uuid = None with self._get_snapshot(instance) as snapshot: - params = {'host':dest, 'vdi_uuid':snapshot.vdi_uuids[1], - 'dest_name': 'base_copy.vhd', + # transfer the base copy + base_copy_uuid = snapshot.vdi_uuids[1] + vdi_ref, vm_vdi_rec = \ + VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) + cow_uuid = vm_vdi_rec['uuid'] + + params = {'host': dest, 'vdi_uuid': base_copy_uuid, 'instance_id': instance.id, } + self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) # Now power down the instance and transfer the COW VHD self._shutdown(instance, vm_ref, method='clean') - vdi_ref, vm_vdi_rec = \ - VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) - params = {'host':dest, 'vdi_uuid': vm_vdi_rec['uuid'], - 'dest_name': 'cow.vhd', + params = {'host': dest, 'vdi_uuid': cow_uuid, 'instance_id': instance.id, } self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) - return snapshot.vdi_uuids[1], vm_vdi_rec['uuid'] - def attach_disk(self, instance): - vm_ref = VMHelper.lookup(self._session, instance.name) + # TODO(mdietz): we could also consider renaming these to something + # sensible so we don't need to blindly pass around dictionaries + return {'base_copy': base_copy_uuid, 'cow': cow_uuid} + def attach_disk(self, instance, disk_info): + vm_ref = VMHelper.lookup(self._session, instance.name) new_base_copy_uuid = str(uuid.uuid4()) - - params = { 'instance_id': instance.id, - 'new_base_copy_uuid': new_base_copy_uuid, - 'new_cow_uuid': str(uuid.uuid4()) } + params = {'instance_id': instance.id, + 'old_base_copy_uuid': disk_info['base_copy'], + 'old_cow_uuid': disk_info['cow'], + 'new_base_copy_uuid': new_base_copy_uuid, + 'new_cow_uuid': str(uuid.uuid4())} self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) @@ -290,7 +297,7 @@ class VMOps(object): # Now we rescan the SR so we find the VHDs VMHelper.scan_sr(self._session) - return new_base_copy_uuid + return new_base_copy_uuid def resize(self, instance, flavor): """Resize a running instance by changing it's RAM and disk size """ @@ -340,7 +347,6 @@ class VMOps(object): raise RuntimeError(resp_dict['message']) return resp_dict['message'] - def _shutdown(self, instance, vm, method='hard'): """Shutdown an instance """ state = self.get_info(instance['name'])['state'] diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 6869ce8d8..21892ca37 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -197,7 +197,7 @@ class XenAPIConnection(object): off the instance copies over the COW disk""" self._vmops.migrate_disk_and_power_off(instance, dest) - def attach_disk(self, instance): + def attach_disk(self, instance, disk_info): """Moves the copied VDIs into the SR""" return self._vmops.attach_disk(instance) -- cgit From 4574bcdfe303a76a46eb7579a5a70de4e54cc926 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 14 Feb 2011 23:58:21 -0600 Subject: Tons o loggin --- nova/virt/xenapi_conn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 21892ca37..6d40d4615 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -195,11 +195,11 @@ class XenAPIConnection(object): def migrate_disk_and_power_off(self, instance, dest): """Transfers the VHD of a running instance to another host, then shuts off the instance copies over the COW disk""" - self._vmops.migrate_disk_and_power_off(instance, dest) + return self._vmops.migrate_disk_and_power_off(instance, dest) def attach_disk(self, instance, disk_info): """Moves the copied VDIs into the SR""" - return self._vmops.attach_disk(instance) + return self._vmops.attach_disk(instance, disk_info) def suspend(self, instance, callback): """suspend the specified instance""" -- cgit From 2dfcfccd74821851c965ee2912fd315e25e7f838 Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Tue, 15 Feb 2011 12:15:49 +0000 Subject: OS-55: Moved conn_common code into disk.py --- nova/virt/conn_common.py | 51 -------------------------------------------- nova/virt/disk.py | 27 +++++++++++++++++++++++ nova/virt/libvirt_conn.py | 3 +-- nova/virt/xenapi/vm_utils.py | 3 +-- 4 files changed, 29 insertions(+), 55 deletions(-) delete mode 100644 nova/virt/conn_common.py (limited to 'nova/virt') diff --git a/nova/virt/conn_common.py b/nova/virt/conn_common.py deleted file mode 100644 index 5550b50c1..000000000 --- a/nova/virt/conn_common.py +++ /dev/null @@ -1,51 +0,0 @@ -# vim: tabstop=4 shiftwidth=4 softtabstop=4 - -# Copyright (c) 2010 Citrix Systems, Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -from nova import context -from nova import db -from nova import exception -from nova import flags -from nova import log as logging -from nova import utils - -LOG = logging.getLogger('nova.virt.conn_common') -FLAGS = flags.FLAGS - -flags.DEFINE_string('injected_network_template', - utils.abspath('virt/interfaces.template'), - 'Template file for injected network') - - -def get_injectables(inst): - key = str(inst['key_data']) - net = None - network_ref = db.network_get_by_instance(context.get_admin_context(), - inst['id']) - if network_ref['injected']: - admin_context = context.get_admin_context() - address = db.instance_get_fixed_address(admin_context, inst['id']) - ra_server = network_ref['ra_server'] - if not ra_server: - ra_server = "fd00::" - with open(FLAGS.injected_network_template) as f: - net = f.read() % {'address': address, - 'netmask': network_ref['netmask'], - 'gateway': network_ref['gateway'], - 'broadcast': network_ref['broadcast'], - 'dns': network_ref['dns'], - 'ra_server': ra_server} - - return key, net diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 98121df2a..cee1ffbce 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -26,6 +26,8 @@ import os import tempfile import time +from nova import context +from nova import db from nova import exception from nova import flags from nova import log as logging @@ -38,6 +40,9 @@ flags.DEFINE_integer('minimum_root_size', 1024 * 1024 * 1024 * 10, 'minimum size in bytes of root partition') flags.DEFINE_integer('block_size', 1024 * 1024 * 256, 'block_size to use for dd') +flags.DEFINE_string('injected_network_template', + utils.abspath('virt/interfaces.template'), + 'Template file for injected network') def extend(image, size): @@ -155,6 +160,28 @@ def _free_device(device): _DEVICES.append(device) +def get_injectables(inst): + key = str(inst['key_data']) + net = None + network_ref = db.network_get_by_instance(context.get_admin_context(), + inst['id']) + if network_ref['injected']: + admin_context = context.get_admin_context() + address = db.instance_get_fixed_address(admin_context, inst['id']) + ra_server = network_ref['ra_server'] + if not ra_server: + ra_server = "fd00::" + with open(FLAGS.injected_network_template) as f: + net = f.read() % {'address': address, + 'netmask': network_ref['netmask'], + 'gateway': network_ref['gateway'], + 'broadcast': network_ref['broadcast'], + 'dns': network_ref['dns'], + 'ra_server': ra_server} + + return key, net + + def inject_data_into_fs(fs, key, net, execute): """Injects data into a filesystem already mounted by the caller. Virt connections can call this directly if they mount their fs diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 45d8754ab..806f35a81 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -62,7 +62,6 @@ from nova.compute import instance_types from nova.compute import power_state from nova.virt import disk from nova.virt import images -from nova.virt import conn_common libvirt = None libxml2 = None @@ -621,7 +620,7 @@ class LibvirtConnection(object): if not inst['kernel_id']: target_partition = "1" - key, net = conn_common.get_injectables(inst) + key, net = disk.get_injectables(inst) if key or net: inst_name = inst['name'] diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index fa60c44c3..603cef1f6 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -41,7 +41,6 @@ from nova.compute import power_state from nova.virt import disk from nova.virt import images from nova.virt.xenapi import HelperBase -from nova.virt import conn_common from nova.virt.xenapi.volume_utils import StorageError @@ -453,7 +452,7 @@ class VMHelper(HelperBase): # if at all, so determine whether it's required first, and then do # everything mount_required = False - key, net = conn_common.get_injectables(instance) + key, net = disk.get_injectables(instance) if key is not None or net is not None: mount_required = True -- cgit From bf82637cad867b0e8fb6ad868f60c6dcd66d7f97 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Feb 2011 11:05:20 -0600 Subject: Better host acquisition --- nova/virt/xenapi_conn.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 6d40d4615..19b5269f5 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -224,6 +224,10 @@ class XenAPIConnection(object): def get_ajax_console(self, instance): """Return link to instance's ajax console""" return self._vmops.get_ajax_console(instance) + + def get_host_ip_addr(self): + xs_url = urlparse.urlpase(FLAGS.xenapi_connection_url) + return xs_url.netloc def attach_volume(self, instance_name, device_path, mountpoint): """Attach volume storage to VM instance""" -- cgit From 03a8d1baae00a4150a02ac2f0b04c413dd3b00e0 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Feb 2011 11:19:27 -0600 Subject: derp --- nova/virt/xenapi_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 19b5269f5..2671f1a7b 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -226,7 +226,7 @@ class XenAPIConnection(object): return self._vmops.get_ajax_console(instance) def get_host_ip_addr(self): - xs_url = urlparse.urlpase(FLAGS.xenapi_connection_url) + xs_url = urlparse.urlparse(FLAGS.xenapi_connection_url) return xs_url.netloc def attach_volume(self, instance_name, device_path, mountpoint): -- cgit From 15cdeef7820aacd0b1ff95da48816cba9f2544ba Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 18:01:13 +0000 Subject: Adding more documentation, code-cleanup --- nova/virt/xenapi/vm_utils.py | 52 ++++++++++++++++++++++++++++++++++---------- 1 file changed, 40 insertions(+), 12 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index a6312d00c..5eab2a38f 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -24,6 +24,7 @@ import pickle import re import time import urllib +import uuid from xml.dom import minidom from eventlet import event @@ -318,9 +319,15 @@ class VMHelper(HelperBase): if sr_ref is None: raise exception.NotFound('Cannot find SR to write VDI to') + # NOTE(sirp): The Glance plugin runs under Python 2.4 which does not + # have the `uuid` module. To work around this, we generate the uuids + # here (under Python 2.6+) and pass them as arguments + uuid_stack = [str(uuid.uuid4()) for i in xrange(2)] + params = {'image_id': image, 'glance_host': FLAGS.glance_host, - 'glance_port': FLAGS.glance_port} + 'glance_port': FLAGS.glance_port, + 'uuid_stack': uuid_stack} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'get_vdi', kwargs) @@ -372,14 +379,35 @@ class VMHelper(HelperBase): @classmethod def determine_disk_image_type(cls, instance): - instance_id = instance.id + """Disk Image Types are used to determine where the kernel will reside + within an image. To figure out which type we're dealing with, we use + the following rules: + + 1. If the instance is specifying a kernel explicitly, we must be using + a 'disk' image (kernel outside of the image) + + 2. If the kernel isn't specified, then we have two different + scenarios: + + a) If the image is in Glance, then we can use the 'disk_format' + property to determine if the image is really a VHD-style image + or if it's a RAW image + + b) If the image is not in Glance, then it must be a RAW image + (since we don't have a way of identifying VHD images...yet) + """ + def log_disk_format(disk_format): + disk_format = disk_format.upper() + image_id = instance.image_id + instance_id = instance.id + LOG.debug(_("Detected %(disk_format)s format for image " + "%(image_id)s, instance %(instance_id)s") % locals()) + if instance.kernel_id: - #if kernel is not present we must download a raw disk - LOG.debug(_("Instance %(instance_id)s will use DISK format") % - locals()) + # 1. DISK + log_disk_format('disk') return ImageType.DISK - - if FLAGS.xenapi_image_service == 'glance': + elif FLAGS.xenapi_image_service == 'glance': # if using glance, then we could be VHD format client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) meta = client.get_image_meta(instance.image_id) @@ -388,12 +416,12 @@ class VMHelper(HelperBase): # TODO(sirp): When Glance treats disk_format as a first class # attribute, we should start using that rather than an image-property if disk_format == 'vhd': - LOG.debug(_("Instance %(instance_id)s will use DISK_VHD format") % - locals()) + # 2a. DISK_VHD + log_disk_format('disk_vhd') return ImageType.DISK_VHD - - LOG.debug(_("Instance %(instance_id)s will use DISK_RAW format") % - locals()) + + # 2b. DISK_RAW + log_disk_format('disk_raw') return ImageType.DISK_RAW @classmethod -- cgit From 0fc3a184230c479254b9f713ea61de2f24f680ab Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 18:23:14 +0000 Subject: Moving SR path code outside of glance plugin --- nova/virt/xenapi/vm_utils.py | 21 +++++++++++++++++++-- nova/virt/xenapi_conn.py | 2 ++ 2 files changed, 21 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 5eab2a38f..e73bc7f2b 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -285,7 +285,8 @@ class VMHelper(HelperBase): params = {'vdi_uuids': vdi_uuids, 'image_id': image_id, 'glance_host': FLAGS.glance_host, - 'glance_port': FLAGS.glance_port} + 'glance_port': FLAGS.glance_port, + 'sr_path': get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'put_vdis', kwargs) @@ -327,7 +328,8 @@ class VMHelper(HelperBase): params = {'image_id': image, 'glance_host': FLAGS.glance_host, 'glance_port': FLAGS.glance_port, - 'uuid_stack': uuid_stack} + 'uuid_stack': uuid_stack, + 'sr_path': get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'get_vdi', kwargs) @@ -685,6 +687,21 @@ def find_sr(session): return None +def get_sr_path(session): + """Return the path to our Storage Repository + + This is used when we're dealing with VHDs directly, either by taking + snapshots or by restoring an image in the DISK_VHD format. + """ + # TODO(sirp): add safe_find_sr + sr_ref = find_sr(session) + if sr_ref is None: + raise Exception('Cannot find SR to read VDI from') + sr_rec = session.get_xenapi().SR.get_record(sr_ref) + sr_uuid = sr_rec["uuid"] + return os.path.join(FLAGS.xenapi_sr_base_path, sr_uuid) + + def remap_vbd_dev(dev): """Return the appropriate location for a plugged-in VBD device diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index a0b0499b8..8ae5684b0 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -100,6 +100,8 @@ flags.DEFINE_integer('xenapi_vhd_coalesce_max_attempts', 5, 'Max number of times to poll for VHD to coalesce.' ' Used only if connection_type=xenapi.') +flags.DEFINE_string('xenapi_sr_base_path', '/var/run/sr-mount', + 'Base path to the storage repository') flags.DEFINE_string('target_host', None, 'iSCSI Target Host') -- cgit From b4b1a7fbd55784157b3084016d4dfe2bd0120e51 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 18:36:17 +0000 Subject: Adding safe_find_sr --- nova/virt/xenapi/vm_utils.py | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index e73bc7f2b..37ce86885 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -316,9 +316,7 @@ class VMHelper(HelperBase): LOG.debug(_("Asking xapi to fetch vhd image %(image)s") % locals()) - sr_ref = find_sr(session) - if sr_ref is None: - raise exception.NotFound('Cannot find SR to write VDI to') + sr_ref = safe_find_sr(session) # NOTE(sirp): The Glance plugin runs under Python 2.4 which does not # have the `uuid` module. To work around this, we generate the uuids @@ -340,16 +338,14 @@ class VMHelper(HelperBase): @classmethod def _fetch_image_glance_disk(cls, session, instance_id, image, access, type): - sr = find_sr(session) - if sr is None: - raise exception.NotFound('Cannot find SR to write VDI to') + sr_ref = safe_find_sr(session) client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) - meta, image_file = client.get_image(image) virtual_size = int(meta['size']) vdi_size = virtual_size LOG.debug(_("Size for image %(image)s:%(virtual_size)d") % locals()) + if type == ImageType.DISK: # Make room for MBR. vdi_size += MBR_SIZE_BYTES @@ -672,7 +668,18 @@ def get_vdi_for_vm_safely(session, vm_ref): return vdi_ref, vdi_rec +def safe_find_sr(session): + """Same as find_sr except raises a NotFound exception if SR cannot be + determined + """ + sr_ref = find_sr(session) + if sr_ref is None: + raise exception.NotFound(_('Cannot find SR to read/write VDI')) + return sr_ref + + def find_sr(session): + """Return the storage repository to hold VM images""" host = session.get_xenapi_host() srs = session.get_xenapi().SR.get_all() for sr in srs: @@ -688,15 +695,12 @@ def find_sr(session): def get_sr_path(session): - """Return the path to our Storage Repository + """Return the path to our storage repository This is used when we're dealing with VHDs directly, either by taking snapshots or by restoring an image in the DISK_VHD format. """ - # TODO(sirp): add safe_find_sr - sr_ref = find_sr(session) - if sr_ref is None: - raise Exception('Cannot find SR to read VDI from') + sr_ref = safe_find_sr(session) sr_rec = session.get_xenapi().SR.get_record(sr_ref) sr_uuid = sr_rec["uuid"] return os.path.join(FLAGS.xenapi_sr_base_path, sr_uuid) -- cgit From acf95a640cfeb0812a55577b6a08bff972ad523b Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 19:17:27 +0000 Subject: Regrouping methods so they make sense --- nova/virt/xenapi/vm_utils.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 37ce86885..ba3e5e423 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -289,7 +289,7 @@ class VMHelper(HelperBase): 'sr_path': get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} - task = session.async_call_plugin('glance', 'put_vdis', kwargs) + task = session.async_call_plugin('glance', 'upload_image', kwargs) session.wait_for_task(instance_id, task) @classmethod @@ -310,7 +310,6 @@ class VMHelper(HelperBase): return cls._fetch_image_objectstore(session, instance_id, image, access, user.secret, type) - @classmethod def _fetch_image_glance_vhd(cls, session, instance_id, image, access, type): LOG.debug(_("Asking xapi to fetch vhd image %(image)s") @@ -330,10 +329,10 @@ class VMHelper(HelperBase): 'sr_path': get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} - task = session.async_call_plugin('glance', 'get_vdi', kwargs) + task = session.async_call_plugin('glance', 'download_image', kwargs) vdi_uuid = session.wait_for_task(instance_id, task) scan_sr(session, instance_id, sr_ref) - LOG.debug(_("Xapi 'get_vdi' returned VDI UUID %(vdi_uuid)s") % locals()) + LOG.debug(_("xapi 'download_image' returned VDI UUID %(vdi_uuid)s") % locals()) return vdi_uuid @classmethod -- cgit From c97d408842a4a5a8e9d379acc13c9c1f5871827f Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Feb 2011 14:10:43 -0600 Subject: Plugin changes --- nova/virt/xenapi/vmops.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 127a09ad1..882d52f38 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -267,16 +267,18 @@ class VMOps(object): params = {'host': dest, 'vdi_uuid': base_copy_uuid, 'instance_id': instance.id, } - self._session.async_call_plugin('migration', 'transfer_vhd', + task = self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) + self._session.wait_for_task(instance.id, task) # Now power down the instance and transfer the COW VHD self._shutdown(instance, vm_ref, method='clean') params = {'host': dest, 'vdi_uuid': cow_uuid, 'instance_id': instance.id, } - self._session.async_call_plugin('migration', 'transfer_vhd', + task = self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) + self._session.wait_for_task(instance.id, task) # TODO(mdietz): we could also consider renaming these to something # sensible so we don't need to blindly pass around dictionaries @@ -291,8 +293,9 @@ class VMOps(object): 'new_base_copy_uuid': new_base_copy_uuid, 'new_cow_uuid': str(uuid.uuid4())} - self._session.async_call_plugin('migration', 'move_vhds_into_sr', - {'params': pickle.dumps(params)}) + task = self._session.async_call_plugin('migration', + 'move_vhds_into_sr', {'params': pickle.dumps(params)}) + self._session.wait_for_task(instance.id, task) # Now we rescan the SR so we find the VHDs VMHelper.scan_sr(self._session) -- cgit From 503749849df73df1732583bc9452e7952bf78ac2 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Tue, 15 Feb 2011 15:25:48 -0600 Subject: moved reset network to after boot durrrrr... --- nova/virt/xenapi/vmops.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 00028cdaa..dd9f48ddf 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -134,9 +134,6 @@ class VMOps(object): VMHelper.create_vif(self._session, vm_ref, network_ref, instance.mac_address) - # call reset networking - self.reset_network(instance) - LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) instance_name = instance.name @@ -164,6 +161,10 @@ class VMOps(object): timer.stop() timer.f = _wait_for_boot + + # call reset networking + self.reset_network(instance) + return timer.start(interval=0.5, now=True) def _get_vm_opaque_ref(self, instance_or_vm): -- cgit From c33378fbbe0fd76e807530522715ba4175af18d8 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 21:54:42 +0000 Subject: Fixing typo --- nova/virt/xenapi/vm_utils.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index ba3e5e423..6fa03ee68 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -331,12 +331,24 @@ class VMHelper(HelperBase): kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'download_image', kwargs) vdi_uuid = session.wait_for_task(instance_id, task) + # TODO(sirp): set name-label on VDI scan_sr(session, instance_id, sr_ref) LOG.debug(_("xapi 'download_image' returned VDI UUID %(vdi_uuid)s") % locals()) return vdi_uuid @classmethod def _fetch_image_glance_disk(cls, session, instance_id, image, access, type): + """Fetch the image from Glance + + NOTE: + Unlike _fetch_image_glance_vhd, this method does not use the Glance + plugin; instead, it streams the disks through domU to the VDI + directly. + + """ + # FIXME(sirp): Since the Glance plugin seems to be required for the VHD disk, + # it may be worth using the plugin for both VHD and RAW and DISK + # restores sr_ref = safe_find_sr(session) client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) @@ -349,7 +361,7 @@ class VMHelper(HelperBase): # Make room for MBR. vdi_size += MBR_SIZE_BYTES - vdi = cls.create_vdi(session, sr, _('Glance image %s') % image, + vdi = cls.create_vdi(session, sr_ref, _('Glance image %s') % image, vdi_size, False) with_vdi_attached_here(session, vdi, False, -- cgit From 24d988263324c9136a1cd9aa5a3a3c4fdf229651 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 22:19:58 +0000 Subject: Set name-label on VDI --- nova/virt/xenapi/vm_utils.py | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 6fa03ee68..738372da0 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -331,8 +331,14 @@ class VMHelper(HelperBase): kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'download_image', kwargs) vdi_uuid = session.wait_for_task(instance_id, task) - # TODO(sirp): set name-label on VDI + scan_sr(session, instance_id, sr_ref) + + # Set the name-label to ease debugging + vdi_ref = session.get_xenapi().VDI.get_by_uuid(vdi_uuid) + name_label = get_name_label_for_image(image) + session.get_xenapi().VDI.set_name_label(vdi_ref, name_label) + LOG.debug(_("xapi 'download_image' returned VDI UUID %(vdi_uuid)s") % locals()) return vdi_uuid @@ -361,8 +367,8 @@ class VMHelper(HelperBase): # Make room for MBR. vdi_size += MBR_SIZE_BYTES - vdi = cls.create_vdi(session, sr_ref, _('Glance image %s') % image, - vdi_size, False) + name_label = get_name_label_for_image(image) + vdi = cls.create_vdi(session, sr_ref, name_label, vdi_size, False) with_vdi_attached_here(session, vdi, False, lambda dev: @@ -848,3 +854,8 @@ def _write_partition(virtual_size, dev): (dest, primary_first, primary_last)) LOG.debug(_('Writing partition table %s done.'), dest) + + +def get_name_label_for_image(image): + # TODO(sirp): This should eventually be the URI for the Glance image + return _('Glance image %s') % image -- cgit From 28ba475d9c32a384570ce6eb0e2f9cfc3dc79a08 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 15 Feb 2011 22:24:48 +0000 Subject: Pep8 fixes --- nova/virt/xenapi/vm_utils.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 738372da0..93009b408 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -311,7 +311,8 @@ class VMHelper(HelperBase): access, user.secret, type) @classmethod - def _fetch_image_glance_vhd(cls, session, instance_id, image, access, type): + def _fetch_image_glance_vhd(cls, session, instance_id, image, access, + type): LOG.debug(_("Asking xapi to fetch vhd image %(image)s") % locals()) @@ -339,11 +340,13 @@ class VMHelper(HelperBase): name_label = get_name_label_for_image(image) session.get_xenapi().VDI.set_name_label(vdi_ref, name_label) - LOG.debug(_("xapi 'download_image' returned VDI UUID %(vdi_uuid)s") % locals()) + LOG.debug(_("xapi 'download_image' returned VDI UUID %(vdi_uuid)s") + % locals()) return vdi_uuid @classmethod - def _fetch_image_glance_disk(cls, session, instance_id, image, access, type): + def _fetch_image_glance_disk(cls, session, instance_id, image, access, + type): """Fetch the image from Glance NOTE: @@ -352,9 +355,9 @@ class VMHelper(HelperBase): directly. """ - # FIXME(sirp): Since the Glance plugin seems to be required for the VHD disk, - # it may be worth using the plugin for both VHD and RAW and DISK - # restores + # FIXME(sirp): Since the Glance plugin seems to be required for the + # VHD disk, it may be worth using the plugin for both VHD and RAW and + # DISK restores sr_ref = safe_find_sr(session) client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) @@ -429,12 +432,13 @@ class VMHelper(HelperBase): properties = meta['properties'] disk_format = properties.get('disk_format', None) # TODO(sirp): When Glance treats disk_format as a first class - # attribute, we should start using that rather than an image-property + # attribute, we should start using that rather than an + # image-property if disk_format == 'vhd': # 2a. DISK_VHD log_disk_format('disk_vhd') return ImageType.DISK_VHD - + # 2b. DISK_RAW log_disk_format('disk_raw') return ImageType.DISK_RAW -- cgit From a6ea6759450aab7eb021e202c68e5301667c74a9 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Feb 2011 17:58:57 -0600 Subject: foo --- nova/virt/xenapi/vmops.py | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 882d52f38..c2f5ddc41 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -97,21 +97,22 @@ class VMOps(object): vdi_uuid = VMHelper.fetch_image(self._session, instance.id, instance.image_id, user, project, disk_image_type) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - #Have a look at the VDI and see if it has a PV kernel - if not instance.kernel_id: - pv_kernel = VMHelper.lookup_image(self._session, instance.id, - vdi_ref) - if instance.kernel_id: - kernel = VMHelper.fetch_image(self._session, instance.id, - instance.kernel_id, user, project, - ImageType.KERNEL_RAMDISK) - if instance.ramdisk_id: - ramdisk = VMHelper.fetch_image(self._session, instance.id, - instance.ramdisk_id, user, project, - ImageType.KERNEL_RAMDISK) else: vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', disk) + #Have a look at the VDI and see if it has a PV kernel + if not instance.kernel_id: + pv_kernel = VMHelper.lookup_image(self._session, instance.id, + vdi_ref) + if instance.kernel_id: + kernel = VMHelper.fetch_image(self._session, instance.id, + instance.kernel_id, user, project, + ImageType.KERNEL_RAMDISK) + if instance.ramdisk_id: + ramdisk = VMHelper.fetch_image(self._session, instance.id, + instance.ramdisk_id, user, project, + ImageType.KERNEL_RAMDISK) + vm_ref = VMHelper.create_vm(self._session, instance, kernel, ramdisk, pv_kernel) VMHelper.create_vbd(session=self._session, vm_ref=vm_ref, -- cgit From bb98e2055002ff3ed2099f60bbe4058d5f5c7b35 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Feb 2011 23:10:29 -0600 Subject: hurr durr --- nova/virt/xenapi/vmops.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index c2f5ddc41..7a176442a 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -288,11 +288,12 @@ class VMOps(object): def attach_disk(self, instance, disk_info): vm_ref = VMHelper.lookup(self._session, instance.name) new_base_copy_uuid = str(uuid.uuid4()) + new_cow_uuid = str(uuid.uuid4()) params = {'instance_id': instance.id, 'old_base_copy_uuid': disk_info['base_copy'], 'old_cow_uuid': disk_info['cow'], 'new_base_copy_uuid': new_base_copy_uuid, - 'new_cow_uuid': str(uuid.uuid4())} + 'new_cow_uuid': new_cow_uuid, } task = self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) @@ -301,7 +302,7 @@ class VMOps(object): # Now we rescan the SR so we find the VHDs VMHelper.scan_sr(self._session) - return new_base_copy_uuid + return new_cow_uuid def resize(self, instance, flavor): """Resize a running instance by changing it's RAM and disk size """ -- cgit From 1b508d80dd76810f6183df50b9d9b324831875be Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 16 Feb 2011 12:01:22 +0000 Subject: First commit for xenapi-vlan-networking. Totally untested --- nova/virt/xenapi/network_utils.py | 17 +++++++++++++++-- nova/virt/xenapi/vm_utils.py | 1 + nova/virt/xenapi/vmops.py | 15 +++++++++++++-- 3 files changed, 29 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py index c0406d8f0..4c2a81260 100644 --- a/nova/virt/xenapi/network_utils.py +++ b/nova/virt/xenapi/network_utils.py @@ -28,7 +28,20 @@ class NetworkHelper(HelperBase): """ The class that wraps the helper methods together. """ - + + + @classmethod + def find_network_with_name_label(cls,session,name_label): + networks = session.call_xenapi('network.get_by_name_label', name_label) + if len(networks) == 1: + return networks.keys()[0] + elif len(networks) > 1: + raise Exception(_('Found non-unique network' + ' for name_label %s') % name_label) + else: + return None + + @classmethod def find_network_with_bridge(cls, session, bridge): """Return the network on which the bridge is attached, if found.""" @@ -40,4 +53,4 @@ class NetworkHelper(HelperBase): raise Exception(_('Found non-unique network' ' for bridge %s') % bridge) else: - raise Exception(_('Found no network for bridge %s') % bridge) + raise Exception(_('Found no network for bridge %s') % bridge) diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index f5c19099a..76257946e 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -204,6 +204,7 @@ class VMHelper(HelperBase): VIF reference.""" vif_rec = {} vif_rec['device'] = '0' + #network_ref should be the appropriate reference (network with VLAN) vif_rec['network'] = network_ref vif_rec['VM'] = vm_ref vif_rec['MAC'] = mac_address diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index fe95d881b..b5c5e082e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -67,10 +67,21 @@ class VMOps(object): raise exception.Duplicate(_('Attempted to create' ' non-unique name %s') % instance.name) + #this will return the bridge name in nova db bridge = db.network_get_by_instance(context.get_admin_context(), instance['id'])['bridge'] - network_ref = \ - NetworkHelper.find_network_with_bridge(self._session, bridge) + + #this will return the appropriate network + #TODO: avoid unnecessary call to find_network_with_bridge + #when VLAN manager is being used (and not just use an if) + network_ref = None + try: + network_ref = \ + NetworkHelper.find_network_with_bridge(self._session, bridge) + except: + #try to get name with name_label + network_ref = \ + NetworkHelper.find_network_with_name_label(self._session,bridge) user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) -- cgit From 01e340f98765cc434624b3b4da49447f950f07ae Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 16 Feb 2011 17:16:31 +0000 Subject: First commit of working code --- nova/virt/xenapi/network_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py index 4c2a81260..8f7806e6c 100644 --- a/nova/virt/xenapi/network_utils.py +++ b/nova/virt/xenapi/network_utils.py @@ -34,7 +34,7 @@ class NetworkHelper(HelperBase): def find_network_with_name_label(cls,session,name_label): networks = session.call_xenapi('network.get_by_name_label', name_label) if len(networks) == 1: - return networks.keys()[0] + return networks[0] elif len(networks) > 1: raise Exception(_('Found non-unique network' ' for name_label %s') % name_label) -- cgit From 552875913e263d0e44be4613f0a07d3b53067e96 Mon Sep 17 00:00:00 2001 From: Andy Southgate Date: Wed, 16 Feb 2011 19:32:45 +0000 Subject: Fixed merge error --- nova/virt/xenapi/vm_utils.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index c5347498d..4b9883d21 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -597,6 +597,7 @@ class VMHelper(HelperBase): session.call_xenapi('VM.add_to_xenstore_data', vm_ref, instance_key + '/data', xenstore_value) + @classmethod def lookup_kernel_ramdisk(cls, session, vm): vm_rec = session.get_xenapi().VM.get_record(vm) if 'PV_kernel' in vm_rec and 'PV_ramdisk' in vm_rec: -- cgit From c56b1814cfae7a9c814b2d37388aff5e772771b6 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Wed, 16 Feb 2011 23:39:12 +0000 Subject: Pep8 fixes --- nova/virt/xenapi/vm_utils.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index d77db2ddb..33945aca3 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -289,6 +289,8 @@ class VMHelper(HelperBase): """ Requests that the Glance plugin bundle the specified VDIs and push them into Glance using the specified human-friendly name. """ + # NOTE(sirp): Currently we only support uploading images as VHD, there + # is no RAW equivalent (yet) logging.debug(_("Asking xapi to upload %(vdi_uuids)s as" " ID %(image_id)s") % locals()) @@ -299,7 +301,7 @@ class VMHelper(HelperBase): 'sr_path': get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} - task = session.async_call_plugin('glance', 'upload_image', kwargs) + task = session.async_call_plugin('glance', 'upload_vhd', kwargs) session.wait_for_task(instance_id, task) @classmethod @@ -340,7 +342,7 @@ class VMHelper(HelperBase): 'sr_path': get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} - task = session.async_call_plugin('glance', 'download_image', kwargs) + task = session.async_call_plugin('glance', 'download_vhd', kwargs) vdi_uuid = session.wait_for_task(instance_id, task) scan_sr(session, instance_id, sr_ref) @@ -350,7 +352,7 @@ class VMHelper(HelperBase): name_label = get_name_label_for_image(image) session.get_xenapi().VDI.set_name_label(vdi_ref, name_label) - LOG.debug(_("xapi 'download_image' returned VDI UUID %(vdi_uuid)s") + LOG.debug(_("xapi 'download_vhd' returned VDI UUID %(vdi_uuid)s") % locals()) return vdi_uuid -- cgit From 04e29f6dc4b13b6fd0cbe5013cf241a727eb56ac Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Thu, 17 Feb 2011 01:24:31 +0000 Subject: Use glance image type to determine disk type --- nova/virt/xenapi/vm_utils.py | 68 +++++++++++++++++++++++--------------------- nova/virt/xenapi/vmops.py | 9 ++++-- 2 files changed, 42 insertions(+), 35 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 33945aca3..278e52211 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -413,47 +413,51 @@ class VMHelper(HelperBase): within an image. To figure out which type we're dealing with, we use the following rules: - 1. If the instance is specifying a kernel explicitly, we must be using - a 'disk' image (kernel outside of the image) + 1. If we're using Glance, we can use the image_type field to + determine the image_type - 2. If the kernel isn't specified, then we have two different - scenarios: - - a) If the image is in Glance, then we can use the 'disk_format' - property to determine if the image is really a VHD-style image - or if it's a RAW image - - b) If the image is not in Glance, then it must be a RAW image - (since we don't have a way of identifying VHD images...yet) + 2. If we're not using Glance, then we need to deduce this based on + whether a kernel_id is specified. """ - def log_disk_format(disk_format): - disk_format = disk_format.upper() + def log_disk_format(image_type): + pretty_format = {ImageType.KERNEL_RAMDISK: 'KERNEL_RAMDISK', + ImageType.DISK: 'DISK', + ImageType.DISK_RAW: 'DISK_RAW', + ImageType.DISK_VHD: 'DISK_VHD'} + disk_format = pretty_format[image_type] image_id = instance.image_id instance_id = instance.id LOG.debug(_("Detected %(disk_format)s format for image " "%(image_id)s, instance %(instance_id)s") % locals()) - if instance.kernel_id: - # 1. DISK - log_disk_format('disk') - return ImageType.DISK - elif FLAGS.xenapi_image_service == 'glance': - # if using glance, then we could be VHD format + def determine_from_glance(): + glance_type2nova_type = {'machine': ImageType.DISK, + 'raw': ImageType.DISK_RAW, + 'vhd': ImageType.DISK_VHD, + 'kernel': ImageType.KERNEL_RAMDISK, + 'ramdisk': ImageType.KERNEL_RAMDISK} client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) meta = client.get_image_meta(instance.image_id) - properties = meta['properties'] - disk_format = properties.get('disk_format', None) - # TODO(sirp): When Glance treats disk_format as a first class - # attribute, we should start using that rather than an - # image-property - if disk_format == 'vhd': - # 2a. DISK_VHD - log_disk_format('disk_vhd') - return ImageType.DISK_VHD - - # 2b. DISK_RAW - log_disk_format('disk_raw') - return ImageType.DISK_RAW + type_ = meta['type'] + try: + return glance_type2nova_type[type_] + except KeyError: + raise exception.NotFound( + _("Unrecognized image type '%(type_)s'") % locals()) + + def determine_from_instance(): + if instance.kernel_id: + return ImageType.DISK + else: + return ImageType.DISK_RAW + + if FLAGS.xenapi_image_service == 'glance': + image_type = determine_from_glance() + else: + image_type = determine_from_instance() + + log_disk_format(image_type) + return image_type @classmethod def _fetch_image_glance(cls, session, instance_id, image, access, type): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 943d74da3..961d589d5 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -224,7 +224,8 @@ class VMOps(object): VMHelper.upload_image( self._session, instance.id, template_vdi_uuids, image_id) finally: - self._destroy(instance, template_vm_ref, shutdown=False) + self._destroy(instance, template_vm_ref, shutdown=False, + destroy_kernel_ramdisk=False) logging.debug(_("Finished snapshot and upload for VM %s"), instance) @@ -368,7 +369,8 @@ class VMOps(object): vm = VMHelper.lookup(self._session, instance.name) return self._destroy(instance, vm, shutdown=True) - def _destroy(self, instance, vm, shutdown=True): + def _destroy(self, instance, vm, shutdown=True, + destroy_kernel_ramdisk=True): """ Destroys VM instance by performing: @@ -385,7 +387,8 @@ class VMOps(object): self._shutdown(instance, vm) self._destroy_vdis(instance, vm) - self._destroy_kernel_ramdisk(instance, vm) + if destroy_kernel_ramdisk: + self._destroy_kernel_ramdisk(instance, vm) self._destroy_vm(instance, vm) def _wait_with_callback(self, instance_id, task, callback): -- cgit From 923a4938b73b84aa8a31f08a7c7b983cc82959fe Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Thu, 17 Feb 2011 07:29:50 +0000 Subject: Adding tests --- nova/virt/xenapi/vm_utils.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 278e52211..9027d58c4 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -490,6 +490,9 @@ class VMHelper(HelperBase): @classmethod def lookup_image(cls, session, instance_id, vdi_ref): + """ + Determine if VDI is using a PV kernel + """ if FLAGS.xenapi_image_service == 'glance': return cls._lookup_image_glance(session, vdi_ref) else: @@ -517,6 +520,7 @@ class VMHelper(HelperBase): def is_vdi_pv(dev): LOG.debug(_("Running pygrub against %s"), dev) + # TODO(sirp): use subprocess here output = os.popen('pygrub -qn /dev/%s' % dev) for line in output.readlines(): #try to find kernel string -- cgit From 7a60b5c406336c5f410d1a98868c3f93d888ea0c Mon Sep 17 00:00:00 2001 From: sateesh Date: Thu, 17 Feb 2011 21:36:08 +0530 Subject: Added vmwareapi module to add support of hypervisor vmware-vsphere to OpenStack. --- nova/virt/guest-tools/guest_tool.bat | 5 + nova/virt/guest-tools/guest_tool.py | 317 + nova/virt/guest-tools/guest_tool.sh | 4 + nova/virt/vmwareapi/VimService_services.py | 8369 +++ nova/virt/vmwareapi/VimService_services_types.py | 72377 +++++++++++++++++++++ nova/virt/vmwareapi/__init__.py | 16 + nova/virt/vmwareapi/io_util.py | 168 + nova/virt/vmwareapi/read_write_util.py | 381 + nova/virt/vmwareapi/vim.py | 195 + nova/virt/vmwareapi/vim_util.py | 291 + nova/virt/vmwareapi/vm_util.py | 321 + nova/virt/vmwareapi/vmops.py | 724 + nova/virt/vmwareapi/vmware_images.py | 257 + nova/virt/vmwareapi_conn.py | 384 + nova/virt/vmwareapi_readme.rst | 72 + 15 files changed, 83881 insertions(+) create mode 100644 nova/virt/guest-tools/guest_tool.bat create mode 100644 nova/virt/guest-tools/guest_tool.py create mode 100644 nova/virt/guest-tools/guest_tool.sh create mode 100644 nova/virt/vmwareapi/VimService_services.py create mode 100644 nova/virt/vmwareapi/VimService_services_types.py create mode 100644 nova/virt/vmwareapi/__init__.py create mode 100644 nova/virt/vmwareapi/io_util.py create mode 100644 nova/virt/vmwareapi/read_write_util.py create mode 100644 nova/virt/vmwareapi/vim.py create mode 100644 nova/virt/vmwareapi/vim_util.py create mode 100644 nova/virt/vmwareapi/vm_util.py create mode 100644 nova/virt/vmwareapi/vmops.py create mode 100644 nova/virt/vmwareapi/vmware_images.py create mode 100644 nova/virt/vmwareapi_conn.py create mode 100644 nova/virt/vmwareapi_readme.rst (limited to 'nova/virt') diff --git a/nova/virt/guest-tools/guest_tool.bat b/nova/virt/guest-tools/guest_tool.bat new file mode 100644 index 000000000..f7445d05c --- /dev/null +++ b/nova/virt/guest-tools/guest_tool.bat @@ -0,0 +1,5 @@ +@echo off + +set GuestToolsHome=%~dp0 +set PATH=%PATH%;%GuestToolsHome%\Python24 +"%GuestToolsHome%\Python24\python.exe" "%GuestToolsHome%\guest_tool.py" \ No newline at end of file diff --git a/nova/virt/guest-tools/guest_tool.py b/nova/virt/guest-tools/guest_tool.py new file mode 100644 index 000000000..c605e47d2 --- /dev/null +++ b/nova/virt/guest-tools/guest_tool.py @@ -0,0 +1,317 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import os +import sys +import subprocess +import time +import array +import struct +import socket +import platform +import logging + +FORMAT = "%(asctime)s - %(levelname)s - %(message)s" +if sys.platform == 'win32': + LOG_DIR = os.path.join(os.environ.get('ALLUSERSPROFILE'), 'openstack') +elif sys.platform == 'linux2': + LOG_DIR = '/var/log/openstack' +else: + LOG_DIR = 'logs' +if not os.path.exists(LOG_DIR): + os.mkdir(LOG_DIR) +LOG_FILENAME = os.path.join(LOG_DIR, 'openstack-guest-tools.log') +logging.basicConfig(filename=LOG_FILENAME, format=FORMAT) + +if sys.hexversion < 0x3000000: + _byte = ord # 2.x chr to integer +else: + _byte = int # 3.x byte to integer + + +class ProcessExecutionError: + """ + Process Execution Error Class + """ + + def __init__(self, exit_code, stdout, stderr, cmd): + """ + The Intializer + """ + self.exit_code = exit_code + self.stdout = stdout + self.stderr = stderr + self.cmd = cmd + + def __str__(self): + """ + The informal string representation of the object + """ + return str(self.exit_code) + + +def _bytes2int(bytes): + """ + convert bytes to int. + """ + intgr = 0 + for byt in bytes: + intgr = (intgr << 8) + _byte(byt) + return intgr + + +def _parse_network_details(machine_id): + """ + Parse the machine.id field to get MAC, IP, Netmask and Gateway feilds + machine.id is of the form MAC;IP;Netmask;Gateway; + ; is the separator + """ + network_details = [] + if machine_id[1].strip() == 'No machine id': + pass + else: + network_info_list = machine_id[0].split(';') + assert len(network_info_list) % 4 == 0 + for i in xrange(0, len(network_info_list) / 4): + network_details.append((network_info_list[i].strip().lower(), + network_info_list[i + 1].strip(), + network_info_list[i + 2].strip(), + network_info_list[i + 3].strip())) + return network_details + + +def _get_windows_network_adapters(): + """ + Get the list of windows network adapters + """ + import win32com.client + wbem_locator = win32com.client.Dispatch('WbemScripting.SWbemLocator') + wbem_service = wbem_locator.ConnectServer('.', 'root\cimv2') + wbem_network_adapters = wbem_service.InstancesOf('Win32_NetworkAdapter') + network_adapters = [] + for wbem_network_adapter in wbem_network_adapters: + if wbem_network_adapter.NetConnectionStatus == 2 or \ + wbem_network_adapter.NetConnectionStatus == 7: + adapter_name = wbem_network_adapter.NetConnectionID + mac_address = wbem_network_adapter.MacAddress.lower() + wbem_network_adapter_config = \ + wbem_network_adapter.associators_( + 'Win32_NetworkAdapterSetting', + 'Win32_NetworkAdapterConfiguration')[0] + ip_address = '' + subnet_mask = '' + if wbem_network_adapter_config.IPEnabled: + ip_address = wbem_network_adapter_config.IPAddress[0] + subnet_mask = wbem_network_adapter_config.IPSubnet[0] + #wbem_network_adapter_config.DefaultIPGateway[0] + network_adapters.append({'name': adapter_name, + 'mac-address': mac_address, + 'ip-address': ip_address, + 'subnet-mask': subnet_mask}) + return network_adapters + + +def _get_linux_network_adapters(): + """ + Get the list of Linux network adapters + """ + import fcntl + max_bytes = 8096 + arch = platform.architecture()[0] + if arch == '32bit': + offset1 = 32 + offset2 = 32 + elif arch == '64bit': + offset1 = 16 + offset2 = 40 + else: + raise OSError("Unknown architecture: %s" % arch) + sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + names = array.array('B', '\0' * max_bytes) + outbytes = struct.unpack('iL', fcntl.ioctl( + sock.fileno(), + 0x8912, + struct.pack('iL', max_bytes, names.buffer_info()[0])))[0] + adapter_names = \ + [names.tostring()[n_counter:n_counter + offset1].split('\0', 1)[0] + for n_counter in xrange(0, outbytes, offset2)] + network_adapters = [] + for adapter_name in adapter_names: + ip_address = socket.inet_ntoa(fcntl.ioctl( + sock.fileno(), + 0x8915, + struct.pack('256s', adapter_name))[20:24]) + subnet_mask = socket.inet_ntoa(fcntl.ioctl( + sock.fileno(), + 0x891b, + struct.pack('256s', adapter_name))[20:24]) + raw_mac_address = '%012x' % _bytes2int(fcntl.ioctl( + sock.fileno(), + 0x8927, + struct.pack('256s', adapter_name))[18:24]) + mac_address = ":".join([raw_mac_address[m_counter:m_counter + 2] + for m_counter in range(0, len(raw_mac_address), 2)]).lower() + network_adapters.append({'name': adapter_name, + 'mac-address': mac_address, + 'ip-address': ip_address, + 'subnet-mask': subnet_mask}) + return network_adapters + + +def _get_adapter_name_and_ip_address(network_adapters, mac_address): + """ + Get the adapter name based on the MAC address + """ + adapter_name = None + ip_address = None + for network_adapter in network_adapters: + if network_adapter['mac-address'] == mac_address.lower(): + adapter_name = network_adapter['name'] + ip_address = network_adapter['ip-address'] + break + return adapter_name, ip_address + + +def _get_win_adapter_name_and_ip_address(mac_address): + """ + Get the Windows network adapter name + """ + network_adapters = _get_windows_network_adapters() + return _get_adapter_name_and_ip_address(network_adapters, mac_address) + + +def _get_linux_adapter_name_and_ip_address(mac_address): + """ + Get the Linux adapter name + """ + network_adapters = _get_linux_network_adapters() + return _get_adapter_name_and_ip_address(network_adapters, mac_address) + + +def _execute(cmd_list, process_input=None, check_exit_code=True): + """ + Executes the command with the list of arguments specified + """ + cmd = ' '.join(cmd_list) + logging.debug('Executing command "%s"' % cmd) + env = os.environ.copy() + obj = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, + stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env) + result = None + if process_input != None: + result = obj.communicate(process_input) + else: + result = obj.communicate() + obj.stdin.close() + if obj.returncode: + logging.debug('Result was %s' % obj.returncode) + if check_exit_code and obj.returncode != 0: + (stdout, stderr) = result + raise ProcessExecutionError(exit_code=obj.returncode, + stdout=stdout, + stderr=stderr, + cmd=cmd) + time.sleep(0.1) + return result + + +def _windows_set_ipaddress(): + """ + Set IP address for the windows VM + """ + program_files = os.environ.get('PROGRAMFILES') + program_files_x86 = os.environ.get('PROGRAMFILES(X86)') + vmware_tools_bin = None + if os.path.exists(os.path.join(program_files, 'VMware', 'VMware Tools', + 'vmtoolsd.exe')): + vmware_tools_bin = os.path.join(program_files, 'VMware', + 'VMware Tools', 'vmtoolsd.exe') + elif os.path.exists(os.path.join(program_files, 'VMware', 'VMware Tools', + 'VMwareService.exe')): + vmware_tools_bin = os.path.join(program_files, 'VMware', + 'VMware Tools', 'VMwareService.exe') + elif program_files_x86 and os.path.exists(os.path.join(program_files_x86, + 'VMware', 'VMware Tools', + 'VMwareService.exe')): + vmware_tools_bin = os.path.join(program_files_x86, 'VMware', + 'VMware Tools', 'VMwareService.exe') + if vmware_tools_bin: + cmd = ['"' + vmware_tools_bin + '"', '--cmd', 'machine.id.get'] + for network_detail in _parse_network_details(_execute(cmd, + check_exit_code=False)): + mac_address, ip_address, subnet_mask, gateway = network_detail + adapter_name, current_ip_address = \ + _get_win_adapter_name_and_ip_address(mac_address) + if adapter_name and not ip_address == current_ip_address: + cmd = ['netsh', 'interface', 'ip', 'set', 'address', + 'name="%s"' % adapter_name, 'source=static', ip_address, + subnet_mask, gateway, '1'] + _execute(cmd) + else: + logging.warn('VMware Tools is not installed') + + +def _linux_set_ipaddress(): + """ + Set IP address for the Linux VM + """ + vmware_tools_bin = None + if os.path.exists('/usr/sbin/vmtoolsd'): + vmware_tools_bin = '/usr/sbin/vmtoolsd' + elif os.path.exists('/usr/bin/vmtoolsd'): + vmware_tools_bin = '/usr/bin/vmtoolsd' + elif os.path.exists('/usr/sbin/vmware-guestd'): + vmware_tools_bin = '/usr/sbin/vmware-guestd' + elif os.path.exists('/usr/bin/vmware-guestd'): + vmware_tools_bin = '/usr/bin/vmware-guestd' + if vmware_tools_bin: + cmd = [vmware_tools_bin, '--cmd', 'machine.id.get'] + for network_detail in _parse_network_details(_execute(cmd, + check_exit_code=False)): + mac_address, ip_address, subnet_mask, gateway = network_detail + adapter_name, current_ip_address = \ + _get_linux_adapter_name_and_ip_address(mac_address) + if adapter_name and not ip_address == current_ip_address: + interface_file_name = \ + '/etc/sysconfig/network-scripts/ifcfg-%s' % adapter_name + #Remove file + os.remove(interface_file_name) + #Touch file + _execute(['touch', interface_file_name]) + interface_file = open(interface_file_name, 'w') + interface_file.write('\nDEVICE=%s' % adapter_name) + interface_file.write('\nUSERCTL=yes') + interface_file.write('\nONBOOT=yes') + interface_file.write('\nBOOTPROTO=static') + interface_file.write('\nBROADCAST=') + interface_file.write('\nNETWORK=') + interface_file.write('\nNETMASK=%s' % subnet_mask) + interface_file.write('\nIPADDR=%s' % ip_address) + interface_file.write('\nMACADDR=%s' % mac_address) + interface_file.close() + _execute(['/sbin/service', 'network' 'restart']) + else: + logging.warn('VMware Tools is not installed') + +if __name__ == '__main__': + pltfrm = sys.platform + if pltfrm == 'win32': + _windows_set_ipaddress() + elif pltfrm == 'linux2': + _linux_set_ipaddress() + else: + raise NotImplementedError('Platform not implemented:"%s"' % pltfrm) diff --git a/nova/virt/guest-tools/guest_tool.sh b/nova/virt/guest-tools/guest_tool.sh new file mode 100644 index 000000000..1bfbc7804 --- /dev/null +++ b/nova/virt/guest-tools/guest_tool.sh @@ -0,0 +1,4 @@ +#!/bin/sh +##!/usr/bin/bash + +python guest_tool.py \ No newline at end of file diff --git a/nova/virt/vmwareapi/VimService_services.py b/nova/virt/vmwareapi/VimService_services.py new file mode 100644 index 000000000..28767ffca --- /dev/null +++ b/nova/virt/vmwareapi/VimService_services.py @@ -0,0 +1,8369 @@ +################################################## +# VimService_services.py +# generated by ZSI.generate.wsdl2python +################################################## + + +from VimService_services_types import * +import urlparse, types +from ZSI.TCcompound import ComplexType, Struct +from ZSI import client +import ZSI +from ZSI.generate.pyclass import pyclass_type + +# Locator +class VimServiceLocator: + VimPortType_address = "https://localhost/sdk/vimService" + def getVimPortTypeAddress(self): + return VimServiceLocator.VimPortType_address + def getVimPortType(self, url=None, **kw): + return VimBindingSOAP(url or VimServiceLocator.VimPortType_address, **kw) + +# Methods +class VimBindingSOAP: + def __init__(self, url, **kw): + kw.setdefault("readerclass", None) + kw.setdefault("writerclass", None) + # no resource properties + self.binding = client.Binding(url=url, **kw) + # no ws-addressing + + # op: DestroyPropertyFilter + def DestroyPropertyFilter(self, request): + if isinstance(request, DestroyPropertyFilterRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyPropertyFilterResponseMsg.typecode) + return response + + # op: CreateFilter + def CreateFilter(self, request): + if isinstance(request, CreateFilterRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateFilterResponseMsg.typecode) + return response + + # op: RetrieveProperties + def RetrieveProperties(self, request): + if isinstance(request, RetrievePropertiesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrievePropertiesResponseMsg.typecode) + return response + + # op: CheckForUpdates + def CheckForUpdates(self, request): + if isinstance(request, CheckForUpdatesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckForUpdatesResponseMsg.typecode) + return response + + # op: WaitForUpdates + def WaitForUpdates(self, request): + if isinstance(request, WaitForUpdatesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(WaitForUpdatesResponseMsg.typecode) + return response + + # op: CancelWaitForUpdates + def CancelWaitForUpdates(self, request): + if isinstance(request, CancelWaitForUpdatesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CancelWaitForUpdatesResponseMsg.typecode) + return response + + # op: AddAuthorizationRole + def AddAuthorizationRole(self, request): + if isinstance(request, AddAuthorizationRoleRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddAuthorizationRoleResponseMsg.typecode) + return response + + # op: RemoveAuthorizationRole + def RemoveAuthorizationRole(self, request): + if isinstance(request, RemoveAuthorizationRoleRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveAuthorizationRoleResponseMsg.typecode) + return response + + # op: UpdateAuthorizationRole + def UpdateAuthorizationRole(self, request): + if isinstance(request, UpdateAuthorizationRoleRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateAuthorizationRoleResponseMsg.typecode) + return response + + # op: MergePermissions + def MergePermissions(self, request): + if isinstance(request, MergePermissionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MergePermissionsResponseMsg.typecode) + return response + + # op: RetrieveRolePermissions + def RetrieveRolePermissions(self, request): + if isinstance(request, RetrieveRolePermissionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveRolePermissionsResponseMsg.typecode) + return response + + # op: RetrieveEntityPermissions + def RetrieveEntityPermissions(self, request): + if isinstance(request, RetrieveEntityPermissionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveEntityPermissionsResponseMsg.typecode) + return response + + # op: RetrieveAllPermissions + def RetrieveAllPermissions(self, request): + if isinstance(request, RetrieveAllPermissionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveAllPermissionsResponseMsg.typecode) + return response + + # op: SetEntityPermissions + def SetEntityPermissions(self, request): + if isinstance(request, SetEntityPermissionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetEntityPermissionsResponseMsg.typecode) + return response + + # op: ResetEntityPermissions + def ResetEntityPermissions(self, request): + if isinstance(request, ResetEntityPermissionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetEntityPermissionsResponseMsg.typecode) + return response + + # op: RemoveEntityPermission + def RemoveEntityPermission(self, request): + if isinstance(request, RemoveEntityPermissionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveEntityPermissionResponseMsg.typecode) + return response + + # op: ReconfigureCluster + def ReconfigureCluster(self, request): + if isinstance(request, ReconfigureClusterRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureClusterResponseMsg.typecode) + return response + + # op: ReconfigureCluster_Task + def ReconfigureCluster_Task(self, request): + if isinstance(request, ReconfigureCluster_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureCluster_TaskResponseMsg.typecode) + return response + + # op: ApplyRecommendation + def ApplyRecommendation(self, request): + if isinstance(request, ApplyRecommendationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ApplyRecommendationResponseMsg.typecode) + return response + + # op: RecommendHostsForVm + def RecommendHostsForVm(self, request): + if isinstance(request, RecommendHostsForVmRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RecommendHostsForVmResponseMsg.typecode) + return response + + # op: AddHost + def AddHost(self, request): + if isinstance(request, AddHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddHostResponseMsg.typecode) + return response + + # op: AddHost_Task + def AddHost_Task(self, request): + if isinstance(request, AddHost_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddHost_TaskResponseMsg.typecode) + return response + + # op: MoveInto + def MoveInto(self, request): + if isinstance(request, MoveIntoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveIntoResponseMsg.typecode) + return response + + # op: MoveInto_Task + def MoveInto_Task(self, request): + if isinstance(request, MoveInto_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveInto_TaskResponseMsg.typecode) + return response + + # op: MoveHostInto + def MoveHostInto(self, request): + if isinstance(request, MoveHostIntoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveHostIntoResponseMsg.typecode) + return response + + # op: MoveHostInto_Task + def MoveHostInto_Task(self, request): + if isinstance(request, MoveHostInto_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveHostInto_TaskResponseMsg.typecode) + return response + + # op: RefreshRecommendation + def RefreshRecommendation(self, request): + if isinstance(request, RefreshRecommendationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshRecommendationResponseMsg.typecode) + return response + + # op: RetrieveDasAdvancedRuntimeInfo + def RetrieveDasAdvancedRuntimeInfo(self, request): + if isinstance(request, RetrieveDasAdvancedRuntimeInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveDasAdvancedRuntimeInfoResponseMsg.typecode) + return response + + # op: ReconfigureComputeResource + def ReconfigureComputeResource(self, request): + if isinstance(request, ReconfigureComputeResourceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureComputeResourceResponseMsg.typecode) + return response + + # op: ReconfigureComputeResource_Task + def ReconfigureComputeResource_Task(self, request): + if isinstance(request, ReconfigureComputeResource_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureComputeResource_TaskResponseMsg.typecode) + return response + + # op: AddCustomFieldDef + def AddCustomFieldDef(self, request): + if isinstance(request, AddCustomFieldDefRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddCustomFieldDefResponseMsg.typecode) + return response + + # op: RemoveCustomFieldDef + def RemoveCustomFieldDef(self, request): + if isinstance(request, RemoveCustomFieldDefRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveCustomFieldDefResponseMsg.typecode) + return response + + # op: RenameCustomFieldDef + def RenameCustomFieldDef(self, request): + if isinstance(request, RenameCustomFieldDefRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RenameCustomFieldDefResponseMsg.typecode) + return response + + # op: SetField + def SetField(self, request): + if isinstance(request, SetFieldRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetFieldResponseMsg.typecode) + return response + + # op: DoesCustomizationSpecExist + def DoesCustomizationSpecExist(self, request): + if isinstance(request, DoesCustomizationSpecExistRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DoesCustomizationSpecExistResponseMsg.typecode) + return response + + # op: GetCustomizationSpec + def GetCustomizationSpec(self, request): + if isinstance(request, GetCustomizationSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GetCustomizationSpecResponseMsg.typecode) + return response + + # op: CreateCustomizationSpec + def CreateCustomizationSpec(self, request): + if isinstance(request, CreateCustomizationSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateCustomizationSpecResponseMsg.typecode) + return response + + # op: OverwriteCustomizationSpec + def OverwriteCustomizationSpec(self, request): + if isinstance(request, OverwriteCustomizationSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(OverwriteCustomizationSpecResponseMsg.typecode) + return response + + # op: DeleteCustomizationSpec + def DeleteCustomizationSpec(self, request): + if isinstance(request, DeleteCustomizationSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DeleteCustomizationSpecResponseMsg.typecode) + return response + + # op: DuplicateCustomizationSpec + def DuplicateCustomizationSpec(self, request): + if isinstance(request, DuplicateCustomizationSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DuplicateCustomizationSpecResponseMsg.typecode) + return response + + # op: RenameCustomizationSpec + def RenameCustomizationSpec(self, request): + if isinstance(request, RenameCustomizationSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RenameCustomizationSpecResponseMsg.typecode) + return response + + # op: CustomizationSpecItemToXml + def CustomizationSpecItemToXml(self, request): + if isinstance(request, CustomizationSpecItemToXmlRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CustomizationSpecItemToXmlResponseMsg.typecode) + return response + + # op: XmlToCustomizationSpecItem + def XmlToCustomizationSpecItem(self, request): + if isinstance(request, XmlToCustomizationSpecItemRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(XmlToCustomizationSpecItemResponseMsg.typecode) + return response + + # op: CheckCustomizationResources + def CheckCustomizationResources(self, request): + if isinstance(request, CheckCustomizationResourcesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckCustomizationResourcesResponseMsg.typecode) + return response + + # op: QueryConnectionInfo + def QueryConnectionInfo(self, request): + if isinstance(request, QueryConnectionInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryConnectionInfoResponseMsg.typecode) + return response + + # op: PowerOnMultiVM + def PowerOnMultiVM(self, request): + if isinstance(request, PowerOnMultiVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOnMultiVMResponseMsg.typecode) + return response + + # op: PowerOnMultiVM_Task + def PowerOnMultiVM_Task(self, request): + if isinstance(request, PowerOnMultiVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOnMultiVM_TaskResponseMsg.typecode) + return response + + # op: RefreshDatastore + def RefreshDatastore(self, request): + if isinstance(request, RefreshDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshDatastoreResponseMsg.typecode) + return response + + # op: RefreshDatastoreStorageInfo + def RefreshDatastoreStorageInfo(self, request): + if isinstance(request, RefreshDatastoreStorageInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshDatastoreStorageInfoResponseMsg.typecode) + return response + + # op: RenameDatastore + def RenameDatastore(self, request): + if isinstance(request, RenameDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RenameDatastoreResponseMsg.typecode) + return response + + # op: DestroyDatastore + def DestroyDatastore(self, request): + if isinstance(request, DestroyDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyDatastoreResponseMsg.typecode) + return response + + # op: QueryDescriptions + def QueryDescriptions(self, request): + if isinstance(request, QueryDescriptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryDescriptionsResponseMsg.typecode) + return response + + # op: BrowseDiagnosticLog + def BrowseDiagnosticLog(self, request): + if isinstance(request, BrowseDiagnosticLogRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(BrowseDiagnosticLogResponseMsg.typecode) + return response + + # op: GenerateLogBundles + def GenerateLogBundles(self, request): + if isinstance(request, GenerateLogBundlesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GenerateLogBundlesResponseMsg.typecode) + return response + + # op: GenerateLogBundles_Task + def GenerateLogBundles_Task(self, request): + if isinstance(request, GenerateLogBundles_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GenerateLogBundles_TaskResponseMsg.typecode) + return response + + # op: DVSFetchKeyOfPorts + def DVSFetchKeyOfPorts(self, request): + if isinstance(request, DVSFetchKeyOfPortsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSFetchKeyOfPortsResponseMsg.typecode) + return response + + # op: DVSFetchPorts + def DVSFetchPorts(self, request): + if isinstance(request, DVSFetchPortsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSFetchPortsResponseMsg.typecode) + return response + + # op: DVSQueryUsedVlanId + def DVSQueryUsedVlanId(self, request): + if isinstance(request, DVSQueryUsedVlanIdRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSQueryUsedVlanIdResponseMsg.typecode) + return response + + # op: DVSReconfigure + def DVSReconfigure(self, request): + if isinstance(request, DVSReconfigureRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSReconfigureResponseMsg.typecode) + return response + + # op: DVSReconfigure_Task + def DVSReconfigure_Task(self, request): + if isinstance(request, DVSReconfigure_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSReconfigure_TaskResponseMsg.typecode) + return response + + # op: DVSPerformProductSpecOperation + def DVSPerformProductSpecOperation(self, request): + if isinstance(request, DVSPerformProductSpecOperationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSPerformProductSpecOperationResponseMsg.typecode) + return response + + # op: DVSPerformProductSpecOperation_Task + def DVSPerformProductSpecOperation_Task(self, request): + if isinstance(request, DVSPerformProductSpecOperation_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSPerformProductSpecOperation_TaskResponseMsg.typecode) + return response + + # op: DVSMerge + def DVSMerge(self, request): + if isinstance(request, DVSMergeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSMergeResponseMsg.typecode) + return response + + # op: DVSMerge_Task + def DVSMerge_Task(self, request): + if isinstance(request, DVSMerge_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSMerge_TaskResponseMsg.typecode) + return response + + # op: DVSAddPortgroups + def DVSAddPortgroups(self, request): + if isinstance(request, DVSAddPortgroupsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSAddPortgroupsResponseMsg.typecode) + return response + + # op: DVSMovePort + def DVSMovePort(self, request): + if isinstance(request, DVSMovePortRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSMovePortResponseMsg.typecode) + return response + + # op: DVSUpdateCapability + def DVSUpdateCapability(self, request): + if isinstance(request, DVSUpdateCapabilityRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSUpdateCapabilityResponseMsg.typecode) + return response + + # op: ReconfigurePort + def ReconfigurePort(self, request): + if isinstance(request, ReconfigurePortRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigurePortResponseMsg.typecode) + return response + + # op: DVSRefreshPortState + def DVSRefreshPortState(self, request): + if isinstance(request, DVSRefreshPortStateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSRefreshPortStateResponseMsg.typecode) + return response + + # op: DVSRectifyHost + def DVSRectifyHost(self, request): + if isinstance(request, DVSRectifyHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSRectifyHostResponseMsg.typecode) + return response + + # op: QueryConfigOptionDescriptor + def QueryConfigOptionDescriptor(self, request): + if isinstance(request, QueryConfigOptionDescriptorRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryConfigOptionDescriptorResponseMsg.typecode) + return response + + # op: QueryConfigOption + def QueryConfigOption(self, request): + if isinstance(request, QueryConfigOptionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryConfigOptionResponseMsg.typecode) + return response + + # op: QueryConfigTarget + def QueryConfigTarget(self, request): + if isinstance(request, QueryConfigTargetRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryConfigTargetResponseMsg.typecode) + return response + + # op: QueryTargetCapabilities + def QueryTargetCapabilities(self, request): + if isinstance(request, QueryTargetCapabilitiesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryTargetCapabilitiesResponseMsg.typecode) + return response + + # op: setCustomValue + def setCustomValue(self, request): + if isinstance(request, setCustomValueRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(setCustomValueResponseMsg.typecode) + return response + + # op: UnregisterExtension + def UnregisterExtension(self, request): + if isinstance(request, UnregisterExtensionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UnregisterExtensionResponseMsg.typecode) + return response + + # op: FindExtension + def FindExtension(self, request): + if isinstance(request, FindExtensionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindExtensionResponseMsg.typecode) + return response + + # op: RegisterExtension + def RegisterExtension(self, request): + if isinstance(request, RegisterExtensionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RegisterExtensionResponseMsg.typecode) + return response + + # op: UpdateExtension + def UpdateExtension(self, request): + if isinstance(request, UpdateExtensionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateExtensionResponseMsg.typecode) + return response + + # op: GetPublicKey + def GetPublicKey(self, request): + if isinstance(request, GetPublicKeyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GetPublicKeyResponseMsg.typecode) + return response + + # op: SetPublicKey + def SetPublicKey(self, request): + if isinstance(request, SetPublicKeyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetPublicKeyResponseMsg.typecode) + return response + + # op: MoveDatastoreFile + def MoveDatastoreFile(self, request): + if isinstance(request, MoveDatastoreFileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveDatastoreFileResponseMsg.typecode) + return response + + # op: MoveDatastoreFile_Task + def MoveDatastoreFile_Task(self, request): + if isinstance(request, MoveDatastoreFile_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveDatastoreFile_TaskResponseMsg.typecode) + return response + + # op: CopyDatastoreFile + def CopyDatastoreFile(self, request): + if isinstance(request, CopyDatastoreFileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CopyDatastoreFileResponseMsg.typecode) + return response + + # op: CopyDatastoreFile_Task + def CopyDatastoreFile_Task(self, request): + if isinstance(request, CopyDatastoreFile_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CopyDatastoreFile_TaskResponseMsg.typecode) + return response + + # op: DeleteDatastoreFile + def DeleteDatastoreFile(self, request): + if isinstance(request, DeleteDatastoreFileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DeleteDatastoreFileResponseMsg.typecode) + return response + + # op: DeleteDatastoreFile_Task + def DeleteDatastoreFile_Task(self, request): + if isinstance(request, DeleteDatastoreFile_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DeleteDatastoreFile_TaskResponseMsg.typecode) + return response + + # op: MakeDirectory + def MakeDirectory(self, request): + if isinstance(request, MakeDirectoryRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MakeDirectoryResponseMsg.typecode) + return response + + # op: ChangeOwner + def ChangeOwner(self, request): + if isinstance(request, ChangeOwnerRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ChangeOwnerResponseMsg.typecode) + return response + + # op: CreateFolder + def CreateFolder(self, request): + if isinstance(request, CreateFolderRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateFolderResponseMsg.typecode) + return response + + # op: MoveIntoFolder + def MoveIntoFolder(self, request): + if isinstance(request, MoveIntoFolderRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveIntoFolderResponseMsg.typecode) + return response + + # op: MoveIntoFolder_Task + def MoveIntoFolder_Task(self, request): + if isinstance(request, MoveIntoFolder_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveIntoFolder_TaskResponseMsg.typecode) + return response + + # op: CreateVM + def CreateVM(self, request): + if isinstance(request, CreateVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateVMResponseMsg.typecode) + return response + + # op: CreateVM_Task + def CreateVM_Task(self, request): + if isinstance(request, CreateVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateVM_TaskResponseMsg.typecode) + return response + + # op: RegisterVM + def RegisterVM(self, request): + if isinstance(request, RegisterVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RegisterVMResponseMsg.typecode) + return response + + # op: RegisterVM_Task + def RegisterVM_Task(self, request): + if isinstance(request, RegisterVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RegisterVM_TaskResponseMsg.typecode) + return response + + # op: CreateCluster + def CreateCluster(self, request): + if isinstance(request, CreateClusterRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateClusterResponseMsg.typecode) + return response + + # op: CreateClusterEx + def CreateClusterEx(self, request): + if isinstance(request, CreateClusterExRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateClusterExResponseMsg.typecode) + return response + + # op: AddStandaloneHost + def AddStandaloneHost(self, request): + if isinstance(request, AddStandaloneHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddStandaloneHostResponseMsg.typecode) + return response + + # op: AddStandaloneHost_Task + def AddStandaloneHost_Task(self, request): + if isinstance(request, AddStandaloneHost_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddStandaloneHost_TaskResponseMsg.typecode) + return response + + # op: CreateDatacenter + def CreateDatacenter(self, request): + if isinstance(request, CreateDatacenterRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateDatacenterResponseMsg.typecode) + return response + + # op: UnregisterAndDestroy + def UnregisterAndDestroy(self, request): + if isinstance(request, UnregisterAndDestroyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UnregisterAndDestroyResponseMsg.typecode) + return response + + # op: UnregisterAndDestroy_Task + def UnregisterAndDestroy_Task(self, request): + if isinstance(request, UnregisterAndDestroy_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UnregisterAndDestroy_TaskResponseMsg.typecode) + return response + + # op: FolderCreateDVS + def FolderCreateDVS(self, request): + if isinstance(request, FolderCreateDVSRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FolderCreateDVSResponseMsg.typecode) + return response + + # op: SetCollectorPageSize + def SetCollectorPageSize(self, request): + if isinstance(request, SetCollectorPageSizeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetCollectorPageSizeResponseMsg.typecode) + return response + + # op: RewindCollector + def RewindCollector(self, request): + if isinstance(request, RewindCollectorRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RewindCollectorResponseMsg.typecode) + return response + + # op: ResetCollector + def ResetCollector(self, request): + if isinstance(request, ResetCollectorRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetCollectorResponseMsg.typecode) + return response + + # op: DestroyCollector + def DestroyCollector(self, request): + if isinstance(request, DestroyCollectorRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyCollectorResponseMsg.typecode) + return response + + # op: QueryHostConnectionInfo + def QueryHostConnectionInfo(self, request): + if isinstance(request, QueryHostConnectionInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryHostConnectionInfoResponseMsg.typecode) + return response + + # op: UpdateSystemResources + def UpdateSystemResources(self, request): + if isinstance(request, UpdateSystemResourcesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateSystemResourcesResponseMsg.typecode) + return response + + # op: ReconnectHost + def ReconnectHost(self, request): + if isinstance(request, ReconnectHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconnectHostResponseMsg.typecode) + return response + + # op: ReconnectHost_Task + def ReconnectHost_Task(self, request): + if isinstance(request, ReconnectHost_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconnectHost_TaskResponseMsg.typecode) + return response + + # op: DisconnectHost + def DisconnectHost(self, request): + if isinstance(request, DisconnectHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisconnectHostResponseMsg.typecode) + return response + + # op: DisconnectHost_Task + def DisconnectHost_Task(self, request): + if isinstance(request, DisconnectHost_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisconnectHost_TaskResponseMsg.typecode) + return response + + # op: EnterMaintenanceMode + def EnterMaintenanceMode(self, request): + if isinstance(request, EnterMaintenanceModeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnterMaintenanceModeResponseMsg.typecode) + return response + + # op: EnterMaintenanceMode_Task + def EnterMaintenanceMode_Task(self, request): + if isinstance(request, EnterMaintenanceMode_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnterMaintenanceMode_TaskResponseMsg.typecode) + return response + + # op: ExitMaintenanceMode + def ExitMaintenanceMode(self, request): + if isinstance(request, ExitMaintenanceModeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExitMaintenanceModeResponseMsg.typecode) + return response + + # op: ExitMaintenanceMode_Task + def ExitMaintenanceMode_Task(self, request): + if isinstance(request, ExitMaintenanceMode_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExitMaintenanceMode_TaskResponseMsg.typecode) + return response + + # op: RebootHost + def RebootHost(self, request): + if isinstance(request, RebootHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RebootHostResponseMsg.typecode) + return response + + # op: RebootHost_Task + def RebootHost_Task(self, request): + if isinstance(request, RebootHost_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RebootHost_TaskResponseMsg.typecode) + return response + + # op: ShutdownHost + def ShutdownHost(self, request): + if isinstance(request, ShutdownHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ShutdownHostResponseMsg.typecode) + return response + + # op: ShutdownHost_Task + def ShutdownHost_Task(self, request): + if isinstance(request, ShutdownHost_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ShutdownHost_TaskResponseMsg.typecode) + return response + + # op: PowerDownHostToStandBy + def PowerDownHostToStandBy(self, request): + if isinstance(request, PowerDownHostToStandByRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerDownHostToStandByResponseMsg.typecode) + return response + + # op: PowerDownHostToStandBy_Task + def PowerDownHostToStandBy_Task(self, request): + if isinstance(request, PowerDownHostToStandBy_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerDownHostToStandBy_TaskResponseMsg.typecode) + return response + + # op: PowerUpHostFromStandBy + def PowerUpHostFromStandBy(self, request): + if isinstance(request, PowerUpHostFromStandByRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerUpHostFromStandByResponseMsg.typecode) + return response + + # op: PowerUpHostFromStandBy_Task + def PowerUpHostFromStandBy_Task(self, request): + if isinstance(request, PowerUpHostFromStandBy_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerUpHostFromStandBy_TaskResponseMsg.typecode) + return response + + # op: QueryMemoryOverhead + def QueryMemoryOverhead(self, request): + if isinstance(request, QueryMemoryOverheadRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryMemoryOverheadResponseMsg.typecode) + return response + + # op: QueryMemoryOverheadEx + def QueryMemoryOverheadEx(self, request): + if isinstance(request, QueryMemoryOverheadExRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryMemoryOverheadExResponseMsg.typecode) + return response + + # op: ReconfigureHostForDAS + def ReconfigureHostForDAS(self, request): + if isinstance(request, ReconfigureHostForDASRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureHostForDASResponseMsg.typecode) + return response + + # op: ReconfigureHostForDAS_Task + def ReconfigureHostForDAS_Task(self, request): + if isinstance(request, ReconfigureHostForDAS_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureHostForDAS_TaskResponseMsg.typecode) + return response + + # op: UpdateFlags + def UpdateFlags(self, request): + if isinstance(request, UpdateFlagsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateFlagsResponseMsg.typecode) + return response + + # op: AcquireCimServicesTicket + def AcquireCimServicesTicket(self, request): + if isinstance(request, AcquireCimServicesTicketRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AcquireCimServicesTicketResponseMsg.typecode) + return response + + # op: UpdateIpmi + def UpdateIpmi(self, request): + if isinstance(request, UpdateIpmiRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateIpmiResponseMsg.typecode) + return response + + # op: HttpNfcLeaseComplete + def HttpNfcLeaseComplete(self, request): + if isinstance(request, HttpNfcLeaseCompleteRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HttpNfcLeaseCompleteResponseMsg.typecode) + return response + + # op: HttpNfcLeaseAbort + def HttpNfcLeaseAbort(self, request): + if isinstance(request, HttpNfcLeaseAbortRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HttpNfcLeaseAbortResponseMsg.typecode) + return response + + # op: HttpNfcLeaseProgress + def HttpNfcLeaseProgress(self, request): + if isinstance(request, HttpNfcLeaseProgressRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HttpNfcLeaseProgressResponseMsg.typecode) + return response + + # op: QueryIpPools + def QueryIpPools(self, request): + if isinstance(request, QueryIpPoolsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryIpPoolsResponseMsg.typecode) + return response + + # op: CreateIpPool + def CreateIpPool(self, request): + if isinstance(request, CreateIpPoolRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateIpPoolResponseMsg.typecode) + return response + + # op: UpdateIpPool + def UpdateIpPool(self, request): + if isinstance(request, UpdateIpPoolRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateIpPoolResponseMsg.typecode) + return response + + # op: DestroyIpPool + def DestroyIpPool(self, request): + if isinstance(request, DestroyIpPoolRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyIpPoolResponseMsg.typecode) + return response + + # op: AssociateIpPool + def AssociateIpPool(self, request): + if isinstance(request, AssociateIpPoolRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AssociateIpPoolResponseMsg.typecode) + return response + + # op: UpdateAssignedLicense + def UpdateAssignedLicense(self, request): + if isinstance(request, UpdateAssignedLicenseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateAssignedLicenseResponseMsg.typecode) + return response + + # op: RemoveAssignedLicense + def RemoveAssignedLicense(self, request): + if isinstance(request, RemoveAssignedLicenseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveAssignedLicenseResponseMsg.typecode) + return response + + # op: QueryAssignedLicenses + def QueryAssignedLicenses(self, request): + if isinstance(request, QueryAssignedLicensesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryAssignedLicensesResponseMsg.typecode) + return response + + # op: IsFeatureAvailable + def IsFeatureAvailable(self, request): + if isinstance(request, IsFeatureAvailableRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(IsFeatureAvailableResponseMsg.typecode) + return response + + # op: SetFeatureInUse + def SetFeatureInUse(self, request): + if isinstance(request, SetFeatureInUseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetFeatureInUseResponseMsg.typecode) + return response + + # op: ResetFeatureInUse + def ResetFeatureInUse(self, request): + if isinstance(request, ResetFeatureInUseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetFeatureInUseResponseMsg.typecode) + return response + + # op: QuerySupportedFeatures + def QuerySupportedFeatures(self, request): + if isinstance(request, QuerySupportedFeaturesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QuerySupportedFeaturesResponseMsg.typecode) + return response + + # op: QueryLicenseSourceAvailability + def QueryLicenseSourceAvailability(self, request): + if isinstance(request, QueryLicenseSourceAvailabilityRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryLicenseSourceAvailabilityResponseMsg.typecode) + return response + + # op: QueryLicenseUsage + def QueryLicenseUsage(self, request): + if isinstance(request, QueryLicenseUsageRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryLicenseUsageResponseMsg.typecode) + return response + + # op: SetLicenseEdition + def SetLicenseEdition(self, request): + if isinstance(request, SetLicenseEditionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetLicenseEditionResponseMsg.typecode) + return response + + # op: CheckLicenseFeature + def CheckLicenseFeature(self, request): + if isinstance(request, CheckLicenseFeatureRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckLicenseFeatureResponseMsg.typecode) + return response + + # op: EnableFeature + def EnableFeature(self, request): + if isinstance(request, EnableFeatureRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnableFeatureResponseMsg.typecode) + return response + + # op: DisableFeature + def DisableFeature(self, request): + if isinstance(request, DisableFeatureRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisableFeatureResponseMsg.typecode) + return response + + # op: ConfigureLicenseSource + def ConfigureLicenseSource(self, request): + if isinstance(request, ConfigureLicenseSourceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ConfigureLicenseSourceResponseMsg.typecode) + return response + + # op: UpdateLicense + def UpdateLicense(self, request): + if isinstance(request, UpdateLicenseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateLicenseResponseMsg.typecode) + return response + + # op: AddLicense + def AddLicense(self, request): + if isinstance(request, AddLicenseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddLicenseResponseMsg.typecode) + return response + + # op: RemoveLicense + def RemoveLicense(self, request): + if isinstance(request, RemoveLicenseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveLicenseResponseMsg.typecode) + return response + + # op: DecodeLicense + def DecodeLicense(self, request): + if isinstance(request, DecodeLicenseRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DecodeLicenseResponseMsg.typecode) + return response + + # op: UpdateLicenseLabel + def UpdateLicenseLabel(self, request): + if isinstance(request, UpdateLicenseLabelRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateLicenseLabelResponseMsg.typecode) + return response + + # op: RemoveLicenseLabel + def RemoveLicenseLabel(self, request): + if isinstance(request, RemoveLicenseLabelRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveLicenseLabelResponseMsg.typecode) + return response + + # op: Reload + def Reload(self, request): + if isinstance(request, ReloadRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReloadResponseMsg.typecode) + return response + + # op: Rename + def Rename(self, request): + if isinstance(request, RenameRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RenameResponseMsg.typecode) + return response + + # op: Rename_Task + def Rename_Task(self, request): + if isinstance(request, Rename_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(Rename_TaskResponseMsg.typecode) + return response + + # op: Destroy + def Destroy(self, request): + if isinstance(request, DestroyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyResponseMsg.typecode) + return response + + # op: Destroy_Task + def Destroy_Task(self, request): + if isinstance(request, Destroy_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(Destroy_TaskResponseMsg.typecode) + return response + + # op: DestroyNetwork + def DestroyNetwork(self, request): + if isinstance(request, DestroyNetworkRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyNetworkResponseMsg.typecode) + return response + + # op: ValidateHost + def ValidateHost(self, request): + if isinstance(request, ValidateHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ValidateHostResponseMsg.typecode) + return response + + # op: ParseDescriptor + def ParseDescriptor(self, request): + if isinstance(request, ParseDescriptorRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ParseDescriptorResponseMsg.typecode) + return response + + # op: CreateImportSpec + def CreateImportSpec(self, request): + if isinstance(request, CreateImportSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateImportSpecResponseMsg.typecode) + return response + + # op: CreateDescriptor + def CreateDescriptor(self, request): + if isinstance(request, CreateDescriptorRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateDescriptorResponseMsg.typecode) + return response + + # op: QueryPerfProviderSummary + def QueryPerfProviderSummary(self, request): + if isinstance(request, QueryPerfProviderSummaryRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPerfProviderSummaryResponseMsg.typecode) + return response + + # op: QueryAvailablePerfMetric + def QueryAvailablePerfMetric(self, request): + if isinstance(request, QueryAvailablePerfMetricRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryAvailablePerfMetricResponseMsg.typecode) + return response + + # op: QueryPerfCounter + def QueryPerfCounter(self, request): + if isinstance(request, QueryPerfCounterRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPerfCounterResponseMsg.typecode) + return response + + # op: QueryPerfCounterByLevel + def QueryPerfCounterByLevel(self, request): + if isinstance(request, QueryPerfCounterByLevelRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPerfCounterByLevelResponseMsg.typecode) + return response + + # op: QueryPerf + def QueryPerf(self, request): + if isinstance(request, QueryPerfRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPerfResponseMsg.typecode) + return response + + # op: QueryPerfComposite + def QueryPerfComposite(self, request): + if isinstance(request, QueryPerfCompositeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPerfCompositeResponseMsg.typecode) + return response + + # op: CreatePerfInterval + def CreatePerfInterval(self, request): + if isinstance(request, CreatePerfIntervalRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreatePerfIntervalResponseMsg.typecode) + return response + + # op: RemovePerfInterval + def RemovePerfInterval(self, request): + if isinstance(request, RemovePerfIntervalRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemovePerfIntervalResponseMsg.typecode) + return response + + # op: UpdatePerfInterval + def UpdatePerfInterval(self, request): + if isinstance(request, UpdatePerfIntervalRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdatePerfIntervalResponseMsg.typecode) + return response + + # op: GetDatabaseSizeEstimate + def GetDatabaseSizeEstimate(self, request): + if isinstance(request, GetDatabaseSizeEstimateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GetDatabaseSizeEstimateResponseMsg.typecode) + return response + + # op: UpdateConfig + def UpdateConfig(self, request): + if isinstance(request, UpdateConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateConfigResponseMsg.typecode) + return response + + # op: MoveIntoResourcePool + def MoveIntoResourcePool(self, request): + if isinstance(request, MoveIntoResourcePoolRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveIntoResourcePoolResponseMsg.typecode) + return response + + # op: UpdateChildResourceConfiguration + def UpdateChildResourceConfiguration(self, request): + if isinstance(request, UpdateChildResourceConfigurationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateChildResourceConfigurationResponseMsg.typecode) + return response + + # op: CreateResourcePool + def CreateResourcePool(self, request): + if isinstance(request, CreateResourcePoolRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateResourcePoolResponseMsg.typecode) + return response + + # op: DestroyChildren + def DestroyChildren(self, request): + if isinstance(request, DestroyChildrenRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyChildrenResponseMsg.typecode) + return response + + # op: CreateVApp + def CreateVApp(self, request): + if isinstance(request, CreateVAppRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateVAppResponseMsg.typecode) + return response + + # op: CreateChildVM + def CreateChildVM(self, request): + if isinstance(request, CreateChildVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateChildVMResponseMsg.typecode) + return response + + # op: CreateChildVM_Task + def CreateChildVM_Task(self, request): + if isinstance(request, CreateChildVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateChildVM_TaskResponseMsg.typecode) + return response + + # op: RegisterChildVM + def RegisterChildVM(self, request): + if isinstance(request, RegisterChildVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RegisterChildVMResponseMsg.typecode) + return response + + # op: RegisterChildVM_Task + def RegisterChildVM_Task(self, request): + if isinstance(request, RegisterChildVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RegisterChildVM_TaskResponseMsg.typecode) + return response + + # op: ImportVApp + def ImportVApp(self, request): + if isinstance(request, ImportVAppRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ImportVAppResponseMsg.typecode) + return response + + # op: FindByUuid + def FindByUuid(self, request): + if isinstance(request, FindByUuidRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindByUuidResponseMsg.typecode) + return response + + # op: FindByDatastorePath + def FindByDatastorePath(self, request): + if isinstance(request, FindByDatastorePathRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindByDatastorePathResponseMsg.typecode) + return response + + # op: FindByDnsName + def FindByDnsName(self, request): + if isinstance(request, FindByDnsNameRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindByDnsNameResponseMsg.typecode) + return response + + # op: FindByIp + def FindByIp(self, request): + if isinstance(request, FindByIpRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindByIpResponseMsg.typecode) + return response + + # op: FindByInventoryPath + def FindByInventoryPath(self, request): + if isinstance(request, FindByInventoryPathRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindByInventoryPathResponseMsg.typecode) + return response + + # op: FindChild + def FindChild(self, request): + if isinstance(request, FindChildRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindChildResponseMsg.typecode) + return response + + # op: FindAllByUuid + def FindAllByUuid(self, request): + if isinstance(request, FindAllByUuidRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindAllByUuidResponseMsg.typecode) + return response + + # op: FindAllByDnsName + def FindAllByDnsName(self, request): + if isinstance(request, FindAllByDnsNameRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindAllByDnsNameResponseMsg.typecode) + return response + + # op: FindAllByIp + def FindAllByIp(self, request): + if isinstance(request, FindAllByIpRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FindAllByIpResponseMsg.typecode) + return response + + # op: CurrentTime + def CurrentTime(self, request): + if isinstance(request, CurrentTimeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CurrentTimeResponseMsg.typecode) + return response + + # op: RetrieveServiceContent + def RetrieveServiceContent(self, request): + if isinstance(request, RetrieveServiceContentRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveServiceContentResponseMsg.typecode) + return response + + # op: ValidateMigration + def ValidateMigration(self, request): + if isinstance(request, ValidateMigrationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ValidateMigrationResponseMsg.typecode) + return response + + # op: QueryVMotionCompatibility + def QueryVMotionCompatibility(self, request): + if isinstance(request, QueryVMotionCompatibilityRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVMotionCompatibilityResponseMsg.typecode) + return response + + # op: RetrieveProductComponents + def RetrieveProductComponents(self, request): + if isinstance(request, RetrieveProductComponentsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveProductComponentsResponseMsg.typecode) + return response + + # op: UpdateServiceMessage + def UpdateServiceMessage(self, request): + if isinstance(request, UpdateServiceMessageRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateServiceMessageResponseMsg.typecode) + return response + + # op: Login + def Login(self, request): + if isinstance(request, LoginRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(LoginResponseMsg.typecode) + return response + + # op: LoginBySSPI + def LoginBySSPI(self, request): + if isinstance(request, LoginBySSPIRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(LoginBySSPIResponseMsg.typecode) + return response + + # op: Logout + def Logout(self, request): + if isinstance(request, LogoutRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(LogoutResponseMsg.typecode) + return response + + # op: AcquireLocalTicket + def AcquireLocalTicket(self, request): + if isinstance(request, AcquireLocalTicketRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AcquireLocalTicketResponseMsg.typecode) + return response + + # op: TerminateSession + def TerminateSession(self, request): + if isinstance(request, TerminateSessionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(TerminateSessionResponseMsg.typecode) + return response + + # op: SetLocale + def SetLocale(self, request): + if isinstance(request, SetLocaleRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetLocaleResponseMsg.typecode) + return response + + # op: LoginExtensionBySubjectName + def LoginExtensionBySubjectName(self, request): + if isinstance(request, LoginExtensionBySubjectNameRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(LoginExtensionBySubjectNameResponseMsg.typecode) + return response + + # op: ImpersonateUser + def ImpersonateUser(self, request): + if isinstance(request, ImpersonateUserRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ImpersonateUserResponseMsg.typecode) + return response + + # op: SessionIsActive + def SessionIsActive(self, request): + if isinstance(request, SessionIsActiveRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SessionIsActiveResponseMsg.typecode) + return response + + # op: AcquireCloneTicket + def AcquireCloneTicket(self, request): + if isinstance(request, AcquireCloneTicketRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AcquireCloneTicketResponseMsg.typecode) + return response + + # op: CloneSession + def CloneSession(self, request): + if isinstance(request, CloneSessionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CloneSessionResponseMsg.typecode) + return response + + # op: CancelTask + def CancelTask(self, request): + if isinstance(request, CancelTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CancelTaskResponseMsg.typecode) + return response + + # op: UpdateProgress + def UpdateProgress(self, request): + if isinstance(request, UpdateProgressRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateProgressResponseMsg.typecode) + return response + + # op: SetTaskState + def SetTaskState(self, request): + if isinstance(request, SetTaskStateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetTaskStateResponseMsg.typecode) + return response + + # op: SetTaskDescription + def SetTaskDescription(self, request): + if isinstance(request, SetTaskDescriptionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetTaskDescriptionResponseMsg.typecode) + return response + + # op: ReadNextTasks + def ReadNextTasks(self, request): + if isinstance(request, ReadNextTasksRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReadNextTasksResponseMsg.typecode) + return response + + # op: ReadPreviousTasks + def ReadPreviousTasks(self, request): + if isinstance(request, ReadPreviousTasksRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReadPreviousTasksResponseMsg.typecode) + return response + + # op: CreateCollectorForTasks + def CreateCollectorForTasks(self, request): + if isinstance(request, CreateCollectorForTasksRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateCollectorForTasksResponseMsg.typecode) + return response + + # op: CreateTask + def CreateTask(self, request): + if isinstance(request, CreateTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateTaskResponseMsg.typecode) + return response + + # op: RetrieveUserGroups + def RetrieveUserGroups(self, request): + if isinstance(request, RetrieveUserGroupsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveUserGroupsResponseMsg.typecode) + return response + + # op: UpdateVAppConfig + def UpdateVAppConfig(self, request): + if isinstance(request, UpdateVAppConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateVAppConfigResponseMsg.typecode) + return response + + # op: CloneVApp + def CloneVApp(self, request): + if isinstance(request, CloneVAppRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CloneVAppResponseMsg.typecode) + return response + + # op: CloneVApp_Task + def CloneVApp_Task(self, request): + if isinstance(request, CloneVApp_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CloneVApp_TaskResponseMsg.typecode) + return response + + # op: ExportVApp + def ExportVApp(self, request): + if isinstance(request, ExportVAppRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExportVAppResponseMsg.typecode) + return response + + # op: PowerOnVApp + def PowerOnVApp(self, request): + if isinstance(request, PowerOnVAppRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOnVAppResponseMsg.typecode) + return response + + # op: PowerOnVApp_Task + def PowerOnVApp_Task(self, request): + if isinstance(request, PowerOnVApp_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOnVApp_TaskResponseMsg.typecode) + return response + + # op: PowerOffVApp + def PowerOffVApp(self, request): + if isinstance(request, PowerOffVAppRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOffVAppResponseMsg.typecode) + return response + + # op: PowerOffVApp_Task + def PowerOffVApp_Task(self, request): + if isinstance(request, PowerOffVApp_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOffVApp_TaskResponseMsg.typecode) + return response + + # op: unregisterVApp + def unregisterVApp(self, request): + if isinstance(request, unregisterVAppRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(unregisterVAppResponseMsg.typecode) + return response + + # op: unregisterVApp_Task + def unregisterVApp_Task(self, request): + if isinstance(request, unregisterVApp_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(unregisterVApp_TaskResponseMsg.typecode) + return response + + # op: CreateVirtualDisk + def CreateVirtualDisk(self, request): + if isinstance(request, CreateVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateVirtualDiskResponseMsg.typecode) + return response + + # op: CreateVirtualDisk_Task + def CreateVirtualDisk_Task(self, request): + if isinstance(request, CreateVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: DeleteVirtualDisk + def DeleteVirtualDisk(self, request): + if isinstance(request, DeleteVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DeleteVirtualDiskResponseMsg.typecode) + return response + + # op: DeleteVirtualDisk_Task + def DeleteVirtualDisk_Task(self, request): + if isinstance(request, DeleteVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DeleteVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: MoveVirtualDisk + def MoveVirtualDisk(self, request): + if isinstance(request, MoveVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveVirtualDiskResponseMsg.typecode) + return response + + # op: MoveVirtualDisk_Task + def MoveVirtualDisk_Task(self, request): + if isinstance(request, MoveVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MoveVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: CopyVirtualDisk + def CopyVirtualDisk(self, request): + if isinstance(request, CopyVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CopyVirtualDiskResponseMsg.typecode) + return response + + # op: CopyVirtualDisk_Task + def CopyVirtualDisk_Task(self, request): + if isinstance(request, CopyVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CopyVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: ExtendVirtualDisk + def ExtendVirtualDisk(self, request): + if isinstance(request, ExtendVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExtendVirtualDiskResponseMsg.typecode) + return response + + # op: ExtendVirtualDisk_Task + def ExtendVirtualDisk_Task(self, request): + if isinstance(request, ExtendVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExtendVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: QueryVirtualDiskFragmentation + def QueryVirtualDiskFragmentation(self, request): + if isinstance(request, QueryVirtualDiskFragmentationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVirtualDiskFragmentationResponseMsg.typecode) + return response + + # op: DefragmentVirtualDisk + def DefragmentVirtualDisk(self, request): + if isinstance(request, DefragmentVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DefragmentVirtualDiskResponseMsg.typecode) + return response + + # op: DefragmentVirtualDisk_Task + def DefragmentVirtualDisk_Task(self, request): + if isinstance(request, DefragmentVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DefragmentVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: ShrinkVirtualDisk + def ShrinkVirtualDisk(self, request): + if isinstance(request, ShrinkVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ShrinkVirtualDiskResponseMsg.typecode) + return response + + # op: ShrinkVirtualDisk_Task + def ShrinkVirtualDisk_Task(self, request): + if isinstance(request, ShrinkVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ShrinkVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: InflateVirtualDisk + def InflateVirtualDisk(self, request): + if isinstance(request, InflateVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(InflateVirtualDiskResponseMsg.typecode) + return response + + # op: InflateVirtualDisk_Task + def InflateVirtualDisk_Task(self, request): + if isinstance(request, InflateVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(InflateVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: EagerZeroVirtualDisk + def EagerZeroVirtualDisk(self, request): + if isinstance(request, EagerZeroVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EagerZeroVirtualDiskResponseMsg.typecode) + return response + + # op: EagerZeroVirtualDisk_Task + def EagerZeroVirtualDisk_Task(self, request): + if isinstance(request, EagerZeroVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EagerZeroVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: ZeroFillVirtualDisk + def ZeroFillVirtualDisk(self, request): + if isinstance(request, ZeroFillVirtualDiskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ZeroFillVirtualDiskResponseMsg.typecode) + return response + + # op: ZeroFillVirtualDisk_Task + def ZeroFillVirtualDisk_Task(self, request): + if isinstance(request, ZeroFillVirtualDisk_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ZeroFillVirtualDisk_TaskResponseMsg.typecode) + return response + + # op: SetVirtualDiskUuid + def SetVirtualDiskUuid(self, request): + if isinstance(request, SetVirtualDiskUuidRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetVirtualDiskUuidResponseMsg.typecode) + return response + + # op: QueryVirtualDiskUuid + def QueryVirtualDiskUuid(self, request): + if isinstance(request, QueryVirtualDiskUuidRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVirtualDiskUuidResponseMsg.typecode) + return response + + # op: QueryVirtualDiskGeometry + def QueryVirtualDiskGeometry(self, request): + if isinstance(request, QueryVirtualDiskGeometryRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVirtualDiskGeometryResponseMsg.typecode) + return response + + # op: RefreshStorageInfo + def RefreshStorageInfo(self, request): + if isinstance(request, RefreshStorageInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshStorageInfoResponseMsg.typecode) + return response + + # op: CreateSnapshot + def CreateSnapshot(self, request): + if isinstance(request, CreateSnapshotRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateSnapshotResponseMsg.typecode) + return response + + # op: CreateSnapshot_Task + def CreateSnapshot_Task(self, request): + if isinstance(request, CreateSnapshot_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateSnapshot_TaskResponseMsg.typecode) + return response + + # op: RevertToCurrentSnapshot + def RevertToCurrentSnapshot(self, request): + if isinstance(request, RevertToCurrentSnapshotRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RevertToCurrentSnapshotResponseMsg.typecode) + return response + + # op: RevertToCurrentSnapshot_Task + def RevertToCurrentSnapshot_Task(self, request): + if isinstance(request, RevertToCurrentSnapshot_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RevertToCurrentSnapshot_TaskResponseMsg.typecode) + return response + + # op: RemoveAllSnapshots + def RemoveAllSnapshots(self, request): + if isinstance(request, RemoveAllSnapshotsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveAllSnapshotsResponseMsg.typecode) + return response + + # op: RemoveAllSnapshots_Task + def RemoveAllSnapshots_Task(self, request): + if isinstance(request, RemoveAllSnapshots_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveAllSnapshots_TaskResponseMsg.typecode) + return response + + # op: ReconfigVM + def ReconfigVM(self, request): + if isinstance(request, ReconfigVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigVMResponseMsg.typecode) + return response + + # op: ReconfigVM_Task + def ReconfigVM_Task(self, request): + if isinstance(request, ReconfigVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigVM_TaskResponseMsg.typecode) + return response + + # op: UpgradeVM + def UpgradeVM(self, request): + if isinstance(request, UpgradeVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpgradeVMResponseMsg.typecode) + return response + + # op: UpgradeVM_Task + def UpgradeVM_Task(self, request): + if isinstance(request, UpgradeVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpgradeVM_TaskResponseMsg.typecode) + return response + + # op: ExtractOvfEnvironment + def ExtractOvfEnvironment(self, request): + if isinstance(request, ExtractOvfEnvironmentRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExtractOvfEnvironmentResponseMsg.typecode) + return response + + # op: PowerOnVM + def PowerOnVM(self, request): + if isinstance(request, PowerOnVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOnVMResponseMsg.typecode) + return response + + # op: PowerOnVM_Task + def PowerOnVM_Task(self, request): + if isinstance(request, PowerOnVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOnVM_TaskResponseMsg.typecode) + return response + + # op: PowerOffVM + def PowerOffVM(self, request): + if isinstance(request, PowerOffVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOffVMResponseMsg.typecode) + return response + + # op: PowerOffVM_Task + def PowerOffVM_Task(self, request): + if isinstance(request, PowerOffVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PowerOffVM_TaskResponseMsg.typecode) + return response + + # op: SuspendVM + def SuspendVM(self, request): + if isinstance(request, SuspendVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SuspendVMResponseMsg.typecode) + return response + + # op: SuspendVM_Task + def SuspendVM_Task(self, request): + if isinstance(request, SuspendVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SuspendVM_TaskResponseMsg.typecode) + return response + + # op: ResetVM + def ResetVM(self, request): + if isinstance(request, ResetVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetVMResponseMsg.typecode) + return response + + # op: ResetVM_Task + def ResetVM_Task(self, request): + if isinstance(request, ResetVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetVM_TaskResponseMsg.typecode) + return response + + # op: ShutdownGuest + def ShutdownGuest(self, request): + if isinstance(request, ShutdownGuestRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ShutdownGuestResponseMsg.typecode) + return response + + # op: RebootGuest + def RebootGuest(self, request): + if isinstance(request, RebootGuestRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RebootGuestResponseMsg.typecode) + return response + + # op: StandbyGuest + def StandbyGuest(self, request): + if isinstance(request, StandbyGuestRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StandbyGuestResponseMsg.typecode) + return response + + # op: AnswerVM + def AnswerVM(self, request): + if isinstance(request, AnswerVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AnswerVMResponseMsg.typecode) + return response + + # op: CustomizeVM + def CustomizeVM(self, request): + if isinstance(request, CustomizeVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CustomizeVMResponseMsg.typecode) + return response + + # op: CustomizeVM_Task + def CustomizeVM_Task(self, request): + if isinstance(request, CustomizeVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CustomizeVM_TaskResponseMsg.typecode) + return response + + # op: CheckCustomizationSpec + def CheckCustomizationSpec(self, request): + if isinstance(request, CheckCustomizationSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckCustomizationSpecResponseMsg.typecode) + return response + + # op: MigrateVM + def MigrateVM(self, request): + if isinstance(request, MigrateVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MigrateVMResponseMsg.typecode) + return response + + # op: MigrateVM_Task + def MigrateVM_Task(self, request): + if isinstance(request, MigrateVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MigrateVM_TaskResponseMsg.typecode) + return response + + # op: RelocateVM + def RelocateVM(self, request): + if isinstance(request, RelocateVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RelocateVMResponseMsg.typecode) + return response + + # op: RelocateVM_Task + def RelocateVM_Task(self, request): + if isinstance(request, RelocateVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RelocateVM_TaskResponseMsg.typecode) + return response + + # op: CloneVM + def CloneVM(self, request): + if isinstance(request, CloneVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CloneVMResponseMsg.typecode) + return response + + # op: CloneVM_Task + def CloneVM_Task(self, request): + if isinstance(request, CloneVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CloneVM_TaskResponseMsg.typecode) + return response + + # op: ExportVm + def ExportVm(self, request): + if isinstance(request, ExportVmRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExportVmResponseMsg.typecode) + return response + + # op: MarkAsTemplate + def MarkAsTemplate(self, request): + if isinstance(request, MarkAsTemplateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MarkAsTemplateResponseMsg.typecode) + return response + + # op: MarkAsVirtualMachine + def MarkAsVirtualMachine(self, request): + if isinstance(request, MarkAsVirtualMachineRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MarkAsVirtualMachineResponseMsg.typecode) + return response + + # op: UnregisterVM + def UnregisterVM(self, request): + if isinstance(request, UnregisterVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UnregisterVMResponseMsg.typecode) + return response + + # op: ResetGuestInformation + def ResetGuestInformation(self, request): + if isinstance(request, ResetGuestInformationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetGuestInformationResponseMsg.typecode) + return response + + # op: MountToolsInstaller + def MountToolsInstaller(self, request): + if isinstance(request, MountToolsInstallerRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MountToolsInstallerResponseMsg.typecode) + return response + + # op: UnmountToolsInstaller + def UnmountToolsInstaller(self, request): + if isinstance(request, UnmountToolsInstallerRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UnmountToolsInstallerResponseMsg.typecode) + return response + + # op: UpgradeTools + def UpgradeTools(self, request): + if isinstance(request, UpgradeToolsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpgradeToolsResponseMsg.typecode) + return response + + # op: UpgradeTools_Task + def UpgradeTools_Task(self, request): + if isinstance(request, UpgradeTools_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpgradeTools_TaskResponseMsg.typecode) + return response + + # op: AcquireMksTicket + def AcquireMksTicket(self, request): + if isinstance(request, AcquireMksTicketRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AcquireMksTicketResponseMsg.typecode) + return response + + # op: SetScreenResolution + def SetScreenResolution(self, request): + if isinstance(request, SetScreenResolutionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetScreenResolutionResponseMsg.typecode) + return response + + # op: DefragmentAllDisks + def DefragmentAllDisks(self, request): + if isinstance(request, DefragmentAllDisksRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DefragmentAllDisksResponseMsg.typecode) + return response + + # op: CreateSecondaryVM + def CreateSecondaryVM(self, request): + if isinstance(request, CreateSecondaryVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateSecondaryVMResponseMsg.typecode) + return response + + # op: CreateSecondaryVM_Task + def CreateSecondaryVM_Task(self, request): + if isinstance(request, CreateSecondaryVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateSecondaryVM_TaskResponseMsg.typecode) + return response + + # op: TurnOffFaultToleranceForVM + def TurnOffFaultToleranceForVM(self, request): + if isinstance(request, TurnOffFaultToleranceForVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(TurnOffFaultToleranceForVMResponseMsg.typecode) + return response + + # op: TurnOffFaultToleranceForVM_Task + def TurnOffFaultToleranceForVM_Task(self, request): + if isinstance(request, TurnOffFaultToleranceForVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(TurnOffFaultToleranceForVM_TaskResponseMsg.typecode) + return response + + # op: MakePrimaryVM + def MakePrimaryVM(self, request): + if isinstance(request, MakePrimaryVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MakePrimaryVMResponseMsg.typecode) + return response + + # op: MakePrimaryVM_Task + def MakePrimaryVM_Task(self, request): + if isinstance(request, MakePrimaryVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(MakePrimaryVM_TaskResponseMsg.typecode) + return response + + # op: TerminateFaultTolerantVM + def TerminateFaultTolerantVM(self, request): + if isinstance(request, TerminateFaultTolerantVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(TerminateFaultTolerantVMResponseMsg.typecode) + return response + + # op: TerminateFaultTolerantVM_Task + def TerminateFaultTolerantVM_Task(self, request): + if isinstance(request, TerminateFaultTolerantVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(TerminateFaultTolerantVM_TaskResponseMsg.typecode) + return response + + # op: DisableSecondaryVM + def DisableSecondaryVM(self, request): + if isinstance(request, DisableSecondaryVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisableSecondaryVMResponseMsg.typecode) + return response + + # op: DisableSecondaryVM_Task + def DisableSecondaryVM_Task(self, request): + if isinstance(request, DisableSecondaryVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisableSecondaryVM_TaskResponseMsg.typecode) + return response + + # op: EnableSecondaryVM + def EnableSecondaryVM(self, request): + if isinstance(request, EnableSecondaryVMRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnableSecondaryVMResponseMsg.typecode) + return response + + # op: EnableSecondaryVM_Task + def EnableSecondaryVM_Task(self, request): + if isinstance(request, EnableSecondaryVM_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnableSecondaryVM_TaskResponseMsg.typecode) + return response + + # op: SetDisplayTopology + def SetDisplayTopology(self, request): + if isinstance(request, SetDisplayTopologyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetDisplayTopologyResponseMsg.typecode) + return response + + # op: StartRecording + def StartRecording(self, request): + if isinstance(request, StartRecordingRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StartRecordingResponseMsg.typecode) + return response + + # op: StartRecording_Task + def StartRecording_Task(self, request): + if isinstance(request, StartRecording_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StartRecording_TaskResponseMsg.typecode) + return response + + # op: StopRecording + def StopRecording(self, request): + if isinstance(request, StopRecordingRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StopRecordingResponseMsg.typecode) + return response + + # op: StopRecording_Task + def StopRecording_Task(self, request): + if isinstance(request, StopRecording_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StopRecording_TaskResponseMsg.typecode) + return response + + # op: StartReplaying + def StartReplaying(self, request): + if isinstance(request, StartReplayingRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StartReplayingResponseMsg.typecode) + return response + + # op: StartReplaying_Task + def StartReplaying_Task(self, request): + if isinstance(request, StartReplaying_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StartReplaying_TaskResponseMsg.typecode) + return response + + # op: StopReplaying + def StopReplaying(self, request): + if isinstance(request, StopReplayingRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StopReplayingResponseMsg.typecode) + return response + + # op: StopReplaying_Task + def StopReplaying_Task(self, request): + if isinstance(request, StopReplaying_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StopReplaying_TaskResponseMsg.typecode) + return response + + # op: PromoteDisks + def PromoteDisks(self, request): + if isinstance(request, PromoteDisksRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PromoteDisksResponseMsg.typecode) + return response + + # op: PromoteDisks_Task + def PromoteDisks_Task(self, request): + if isinstance(request, PromoteDisks_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PromoteDisks_TaskResponseMsg.typecode) + return response + + # op: CreateScreenshot + def CreateScreenshot(self, request): + if isinstance(request, CreateScreenshotRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateScreenshotResponseMsg.typecode) + return response + + # op: CreateScreenshot_Task + def CreateScreenshot_Task(self, request): + if isinstance(request, CreateScreenshot_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateScreenshot_TaskResponseMsg.typecode) + return response + + # op: QueryChangedDiskAreas + def QueryChangedDiskAreas(self, request): + if isinstance(request, QueryChangedDiskAreasRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryChangedDiskAreasResponseMsg.typecode) + return response + + # op: QueryUnownedFiles + def QueryUnownedFiles(self, request): + if isinstance(request, QueryUnownedFilesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryUnownedFilesResponseMsg.typecode) + return response + + # op: RemoveAlarm + def RemoveAlarm(self, request): + if isinstance(request, RemoveAlarmRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveAlarmResponseMsg.typecode) + return response + + # op: ReconfigureAlarm + def ReconfigureAlarm(self, request): + if isinstance(request, ReconfigureAlarmRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureAlarmResponseMsg.typecode) + return response + + # op: CreateAlarm + def CreateAlarm(self, request): + if isinstance(request, CreateAlarmRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateAlarmResponseMsg.typecode) + return response + + # op: GetAlarm + def GetAlarm(self, request): + if isinstance(request, GetAlarmRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GetAlarmResponseMsg.typecode) + return response + + # op: GetAlarmActionsEnabled + def GetAlarmActionsEnabled(self, request): + if isinstance(request, GetAlarmActionsEnabledRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GetAlarmActionsEnabledResponseMsg.typecode) + return response + + # op: SetAlarmActionsEnabled + def SetAlarmActionsEnabled(self, request): + if isinstance(request, SetAlarmActionsEnabledRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetAlarmActionsEnabledResponseMsg.typecode) + return response + + # op: GetAlarmState + def GetAlarmState(self, request): + if isinstance(request, GetAlarmStateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(GetAlarmStateResponseMsg.typecode) + return response + + # op: AcknowledgeAlarm + def AcknowledgeAlarm(self, request): + if isinstance(request, AcknowledgeAlarmRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AcknowledgeAlarmResponseMsg.typecode) + return response + + # op: DVPortgroupReconfigure + def DVPortgroupReconfigure(self, request): + if isinstance(request, DVPortgroupReconfigureRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVPortgroupReconfigureResponseMsg.typecode) + return response + + # op: DVSManagerQueryAvailableSwitchSpec + def DVSManagerQueryAvailableSwitchSpec(self, request): + if isinstance(request, DVSManagerQueryAvailableSwitchSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSManagerQueryAvailableSwitchSpecResponseMsg.typecode) + return response + + # op: DVSManagerQueryCompatibleHostForNewDvs + def DVSManagerQueryCompatibleHostForNewDvs(self, request): + if isinstance(request, DVSManagerQueryCompatibleHostForNewDvsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSManagerQueryCompatibleHostForNewDvsResponseMsg.typecode) + return response + + # op: DVSManagerQueryCompatibleHostForExistingDvs + def DVSManagerQueryCompatibleHostForExistingDvs(self, request): + if isinstance(request, DVSManagerQueryCompatibleHostForExistingDvsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSManagerQueryCompatibleHostForExistingDvsResponseMsg.typecode) + return response + + # op: DVSManagerQueryCompatibleHostSpec + def DVSManagerQueryCompatibleHostSpec(self, request): + if isinstance(request, DVSManagerQueryCompatibleHostSpecRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSManagerQueryCompatibleHostSpecResponseMsg.typecode) + return response + + # op: DVSManagerQuerySwitchByUuid + def DVSManagerQuerySwitchByUuid(self, request): + if isinstance(request, DVSManagerQuerySwitchByUuidRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSManagerQuerySwitchByUuidResponseMsg.typecode) + return response + + # op: DVSManagerQueryDvsConfigTarget + def DVSManagerQueryDvsConfigTarget(self, request): + if isinstance(request, DVSManagerQueryDvsConfigTargetRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DVSManagerQueryDvsConfigTargetResponseMsg.typecode) + return response + + # op: ReadNextEvents + def ReadNextEvents(self, request): + if isinstance(request, ReadNextEventsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReadNextEventsResponseMsg.typecode) + return response + + # op: ReadPreviousEvents + def ReadPreviousEvents(self, request): + if isinstance(request, ReadPreviousEventsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReadPreviousEventsResponseMsg.typecode) + return response + + # op: RetrieveArgumentDescription + def RetrieveArgumentDescription(self, request): + if isinstance(request, RetrieveArgumentDescriptionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveArgumentDescriptionResponseMsg.typecode) + return response + + # op: CreateCollectorForEvents + def CreateCollectorForEvents(self, request): + if isinstance(request, CreateCollectorForEventsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateCollectorForEventsResponseMsg.typecode) + return response + + # op: LogUserEvent + def LogUserEvent(self, request): + if isinstance(request, LogUserEventRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(LogUserEventResponseMsg.typecode) + return response + + # op: QueryEvents + def QueryEvents(self, request): + if isinstance(request, QueryEventsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryEventsResponseMsg.typecode) + return response + + # op: PostEvent + def PostEvent(self, request): + if isinstance(request, PostEventRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(PostEventResponseMsg.typecode) + return response + + # op: ReconfigureAutostart + def ReconfigureAutostart(self, request): + if isinstance(request, ReconfigureAutostartRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureAutostartResponseMsg.typecode) + return response + + # op: AutoStartPowerOn + def AutoStartPowerOn(self, request): + if isinstance(request, AutoStartPowerOnRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AutoStartPowerOnResponseMsg.typecode) + return response + + # op: AutoStartPowerOff + def AutoStartPowerOff(self, request): + if isinstance(request, AutoStartPowerOffRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AutoStartPowerOffResponseMsg.typecode) + return response + + # op: QueryBootDevices + def QueryBootDevices(self, request): + if isinstance(request, QueryBootDevicesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryBootDevicesResponseMsg.typecode) + return response + + # op: UpdateBootDevice + def UpdateBootDevice(self, request): + if isinstance(request, UpdateBootDeviceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateBootDeviceResponseMsg.typecode) + return response + + # op: EnableHyperThreading + def EnableHyperThreading(self, request): + if isinstance(request, EnableHyperThreadingRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnableHyperThreadingResponseMsg.typecode) + return response + + # op: DisableHyperThreading + def DisableHyperThreading(self, request): + if isinstance(request, DisableHyperThreadingRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisableHyperThreadingResponseMsg.typecode) + return response + + # op: SearchDatastore + def SearchDatastore(self, request): + if isinstance(request, SearchDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SearchDatastoreResponseMsg.typecode) + return response + + # op: SearchDatastore_Task + def SearchDatastore_Task(self, request): + if isinstance(request, SearchDatastore_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SearchDatastore_TaskResponseMsg.typecode) + return response + + # op: SearchDatastoreSubFolders + def SearchDatastoreSubFolders(self, request): + if isinstance(request, SearchDatastoreSubFoldersRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SearchDatastoreSubFoldersResponseMsg.typecode) + return response + + # op: SearchDatastoreSubFolders_Task + def SearchDatastoreSubFolders_Task(self, request): + if isinstance(request, SearchDatastoreSubFolders_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SearchDatastoreSubFolders_TaskResponseMsg.typecode) + return response + + # op: DeleteFile + def DeleteFile(self, request): + if isinstance(request, DeleteFileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DeleteFileResponseMsg.typecode) + return response + + # op: UpdateLocalSwapDatastore + def UpdateLocalSwapDatastore(self, request): + if isinstance(request, UpdateLocalSwapDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateLocalSwapDatastoreResponseMsg.typecode) + return response + + # op: QueryAvailableDisksForVmfs + def QueryAvailableDisksForVmfs(self, request): + if isinstance(request, QueryAvailableDisksForVmfsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryAvailableDisksForVmfsResponseMsg.typecode) + return response + + # op: QueryVmfsDatastoreCreateOptions + def QueryVmfsDatastoreCreateOptions(self, request): + if isinstance(request, QueryVmfsDatastoreCreateOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVmfsDatastoreCreateOptionsResponseMsg.typecode) + return response + + # op: CreateVmfsDatastore + def CreateVmfsDatastore(self, request): + if isinstance(request, CreateVmfsDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateVmfsDatastoreResponseMsg.typecode) + return response + + # op: QueryVmfsDatastoreExtendOptions + def QueryVmfsDatastoreExtendOptions(self, request): + if isinstance(request, QueryVmfsDatastoreExtendOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVmfsDatastoreExtendOptionsResponseMsg.typecode) + return response + + # op: QueryVmfsDatastoreExpandOptions + def QueryVmfsDatastoreExpandOptions(self, request): + if isinstance(request, QueryVmfsDatastoreExpandOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVmfsDatastoreExpandOptionsResponseMsg.typecode) + return response + + # op: ExtendVmfsDatastore + def ExtendVmfsDatastore(self, request): + if isinstance(request, ExtendVmfsDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExtendVmfsDatastoreResponseMsg.typecode) + return response + + # op: ExpandVmfsDatastore + def ExpandVmfsDatastore(self, request): + if isinstance(request, ExpandVmfsDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExpandVmfsDatastoreResponseMsg.typecode) + return response + + # op: CreateNasDatastore + def CreateNasDatastore(self, request): + if isinstance(request, CreateNasDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateNasDatastoreResponseMsg.typecode) + return response + + # op: CreateLocalDatastore + def CreateLocalDatastore(self, request): + if isinstance(request, CreateLocalDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateLocalDatastoreResponseMsg.typecode) + return response + + # op: RemoveDatastore + def RemoveDatastore(self, request): + if isinstance(request, RemoveDatastoreRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveDatastoreResponseMsg.typecode) + return response + + # op: ConfigureDatastorePrincipal + def ConfigureDatastorePrincipal(self, request): + if isinstance(request, ConfigureDatastorePrincipalRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ConfigureDatastorePrincipalResponseMsg.typecode) + return response + + # op: QueryUnresolvedVmfsVolumes + def QueryUnresolvedVmfsVolumes(self, request): + if isinstance(request, QueryUnresolvedVmfsVolumesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryUnresolvedVmfsVolumesResponseMsg.typecode) + return response + + # op: ResignatureUnresolvedVmfsVolume + def ResignatureUnresolvedVmfsVolume(self, request): + if isinstance(request, ResignatureUnresolvedVmfsVolumeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResignatureUnresolvedVmfsVolumeResponseMsg.typecode) + return response + + # op: ResignatureUnresolvedVmfsVolume_Task + def ResignatureUnresolvedVmfsVolume_Task(self, request): + if isinstance(request, ResignatureUnresolvedVmfsVolume_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResignatureUnresolvedVmfsVolume_TaskResponseMsg.typecode) + return response + + # op: UpdateDateTimeConfig + def UpdateDateTimeConfig(self, request): + if isinstance(request, UpdateDateTimeConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateDateTimeConfigResponseMsg.typecode) + return response + + # op: QueryAvailableTimeZones + def QueryAvailableTimeZones(self, request): + if isinstance(request, QueryAvailableTimeZonesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryAvailableTimeZonesResponseMsg.typecode) + return response + + # op: QueryDateTime + def QueryDateTime(self, request): + if isinstance(request, QueryDateTimeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryDateTimeResponseMsg.typecode) + return response + + # op: UpdateDateTime + def UpdateDateTime(self, request): + if isinstance(request, UpdateDateTimeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateDateTimeResponseMsg.typecode) + return response + + # op: RefreshDateTimeSystem + def RefreshDateTimeSystem(self, request): + if isinstance(request, RefreshDateTimeSystemRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshDateTimeSystemResponseMsg.typecode) + return response + + # op: QueryAvailablePartition + def QueryAvailablePartition(self, request): + if isinstance(request, QueryAvailablePartitionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryAvailablePartitionResponseMsg.typecode) + return response + + # op: SelectActivePartition + def SelectActivePartition(self, request): + if isinstance(request, SelectActivePartitionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SelectActivePartitionResponseMsg.typecode) + return response + + # op: QueryPartitionCreateOptions + def QueryPartitionCreateOptions(self, request): + if isinstance(request, QueryPartitionCreateOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPartitionCreateOptionsResponseMsg.typecode) + return response + + # op: QueryPartitionCreateDesc + def QueryPartitionCreateDesc(self, request): + if isinstance(request, QueryPartitionCreateDescRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPartitionCreateDescResponseMsg.typecode) + return response + + # op: CreateDiagnosticPartition + def CreateDiagnosticPartition(self, request): + if isinstance(request, CreateDiagnosticPartitionRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateDiagnosticPartitionResponseMsg.typecode) + return response + + # op: UpdateDefaultPolicy + def UpdateDefaultPolicy(self, request): + if isinstance(request, UpdateDefaultPolicyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateDefaultPolicyResponseMsg.typecode) + return response + + # op: EnableRuleset + def EnableRuleset(self, request): + if isinstance(request, EnableRulesetRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnableRulesetResponseMsg.typecode) + return response + + # op: DisableRuleset + def DisableRuleset(self, request): + if isinstance(request, DisableRulesetRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisableRulesetResponseMsg.typecode) + return response + + # op: RefreshFirewall + def RefreshFirewall(self, request): + if isinstance(request, RefreshFirewallRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshFirewallResponseMsg.typecode) + return response + + # op: ResetFirmwareToFactoryDefaults + def ResetFirmwareToFactoryDefaults(self, request): + if isinstance(request, ResetFirmwareToFactoryDefaultsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetFirmwareToFactoryDefaultsResponseMsg.typecode) + return response + + # op: BackupFirmwareConfiguration + def BackupFirmwareConfiguration(self, request): + if isinstance(request, BackupFirmwareConfigurationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(BackupFirmwareConfigurationResponseMsg.typecode) + return response + + # op: QueryFirmwareConfigUploadURL + def QueryFirmwareConfigUploadURL(self, request): + if isinstance(request, QueryFirmwareConfigUploadURLRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryFirmwareConfigUploadURLResponseMsg.typecode) + return response + + # op: RestoreFirmwareConfiguration + def RestoreFirmwareConfiguration(self, request): + if isinstance(request, RestoreFirmwareConfigurationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RestoreFirmwareConfigurationResponseMsg.typecode) + return response + + # op: RefreshHealthStatusSystem + def RefreshHealthStatusSystem(self, request): + if isinstance(request, RefreshHealthStatusSystemRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshHealthStatusSystemResponseMsg.typecode) + return response + + # op: ResetSystemHealthInfo + def ResetSystemHealthInfo(self, request): + if isinstance(request, ResetSystemHealthInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetSystemHealthInfoResponseMsg.typecode) + return response + + # op: QueryModules + def QueryModules(self, request): + if isinstance(request, QueryModulesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryModulesResponseMsg.typecode) + return response + + # op: UpdateModuleOptionString + def UpdateModuleOptionString(self, request): + if isinstance(request, UpdateModuleOptionStringRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateModuleOptionStringResponseMsg.typecode) + return response + + # op: QueryConfiguredModuleOptionString + def QueryConfiguredModuleOptionString(self, request): + if isinstance(request, QueryConfiguredModuleOptionStringRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryConfiguredModuleOptionStringResponseMsg.typecode) + return response + + # op: CreateUser + def CreateUser(self, request): + if isinstance(request, CreateUserRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateUserResponseMsg.typecode) + return response + + # op: UpdateUser + def UpdateUser(self, request): + if isinstance(request, UpdateUserRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateUserResponseMsg.typecode) + return response + + # op: CreateGroup + def CreateGroup(self, request): + if isinstance(request, CreateGroupRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateGroupResponseMsg.typecode) + return response + + # op: RemoveUser + def RemoveUser(self, request): + if isinstance(request, RemoveUserRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveUserResponseMsg.typecode) + return response + + # op: RemoveGroup + def RemoveGroup(self, request): + if isinstance(request, RemoveGroupRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveGroupResponseMsg.typecode) + return response + + # op: AssignUserToGroup + def AssignUserToGroup(self, request): + if isinstance(request, AssignUserToGroupRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AssignUserToGroupResponseMsg.typecode) + return response + + # op: UnassignUserFromGroup + def UnassignUserFromGroup(self, request): + if isinstance(request, UnassignUserFromGroupRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UnassignUserFromGroupResponseMsg.typecode) + return response + + # op: ReconfigureServiceConsoleReservation + def ReconfigureServiceConsoleReservation(self, request): + if isinstance(request, ReconfigureServiceConsoleReservationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureServiceConsoleReservationResponseMsg.typecode) + return response + + # op: ReconfigureVirtualMachineReservation + def ReconfigureVirtualMachineReservation(self, request): + if isinstance(request, ReconfigureVirtualMachineReservationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureVirtualMachineReservationResponseMsg.typecode) + return response + + # op: UpdateNetworkConfig + def UpdateNetworkConfig(self, request): + if isinstance(request, UpdateNetworkConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateNetworkConfigResponseMsg.typecode) + return response + + # op: UpdateDnsConfig + def UpdateDnsConfig(self, request): + if isinstance(request, UpdateDnsConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateDnsConfigResponseMsg.typecode) + return response + + # op: UpdateIpRouteConfig + def UpdateIpRouteConfig(self, request): + if isinstance(request, UpdateIpRouteConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateIpRouteConfigResponseMsg.typecode) + return response + + # op: UpdateConsoleIpRouteConfig + def UpdateConsoleIpRouteConfig(self, request): + if isinstance(request, UpdateConsoleIpRouteConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateConsoleIpRouteConfigResponseMsg.typecode) + return response + + # op: UpdateIpRouteTableConfig + def UpdateIpRouteTableConfig(self, request): + if isinstance(request, UpdateIpRouteTableConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateIpRouteTableConfigResponseMsg.typecode) + return response + + # op: AddVirtualSwitch + def AddVirtualSwitch(self, request): + if isinstance(request, AddVirtualSwitchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddVirtualSwitchResponseMsg.typecode) + return response + + # op: RemoveVirtualSwitch + def RemoveVirtualSwitch(self, request): + if isinstance(request, RemoveVirtualSwitchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveVirtualSwitchResponseMsg.typecode) + return response + + # op: UpdateVirtualSwitch + def UpdateVirtualSwitch(self, request): + if isinstance(request, UpdateVirtualSwitchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateVirtualSwitchResponseMsg.typecode) + return response + + # op: AddPortGroup + def AddPortGroup(self, request): + if isinstance(request, AddPortGroupRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddPortGroupResponseMsg.typecode) + return response + + # op: RemovePortGroup + def RemovePortGroup(self, request): + if isinstance(request, RemovePortGroupRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemovePortGroupResponseMsg.typecode) + return response + + # op: UpdatePortGroup + def UpdatePortGroup(self, request): + if isinstance(request, UpdatePortGroupRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdatePortGroupResponseMsg.typecode) + return response + + # op: UpdatePhysicalNicLinkSpeed + def UpdatePhysicalNicLinkSpeed(self, request): + if isinstance(request, UpdatePhysicalNicLinkSpeedRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdatePhysicalNicLinkSpeedResponseMsg.typecode) + return response + + # op: QueryNetworkHint + def QueryNetworkHint(self, request): + if isinstance(request, QueryNetworkHintRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryNetworkHintResponseMsg.typecode) + return response + + # op: AddVirtualNic + def AddVirtualNic(self, request): + if isinstance(request, AddVirtualNicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddVirtualNicResponseMsg.typecode) + return response + + # op: RemoveVirtualNic + def RemoveVirtualNic(self, request): + if isinstance(request, RemoveVirtualNicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveVirtualNicResponseMsg.typecode) + return response + + # op: UpdateVirtualNic + def UpdateVirtualNic(self, request): + if isinstance(request, UpdateVirtualNicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateVirtualNicResponseMsg.typecode) + return response + + # op: AddServiceConsoleVirtualNic + def AddServiceConsoleVirtualNic(self, request): + if isinstance(request, AddServiceConsoleVirtualNicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddServiceConsoleVirtualNicResponseMsg.typecode) + return response + + # op: RemoveServiceConsoleVirtualNic + def RemoveServiceConsoleVirtualNic(self, request): + if isinstance(request, RemoveServiceConsoleVirtualNicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveServiceConsoleVirtualNicResponseMsg.typecode) + return response + + # op: UpdateServiceConsoleVirtualNic + def UpdateServiceConsoleVirtualNic(self, request): + if isinstance(request, UpdateServiceConsoleVirtualNicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateServiceConsoleVirtualNicResponseMsg.typecode) + return response + + # op: RestartServiceConsoleVirtualNic + def RestartServiceConsoleVirtualNic(self, request): + if isinstance(request, RestartServiceConsoleVirtualNicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RestartServiceConsoleVirtualNicResponseMsg.typecode) + return response + + # op: RefreshNetworkSystem + def RefreshNetworkSystem(self, request): + if isinstance(request, RefreshNetworkSystemRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshNetworkSystemResponseMsg.typecode) + return response + + # op: CheckHostPatch + def CheckHostPatch(self, request): + if isinstance(request, CheckHostPatchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckHostPatchResponseMsg.typecode) + return response + + # op: CheckHostPatch_Task + def CheckHostPatch_Task(self, request): + if isinstance(request, CheckHostPatch_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckHostPatch_TaskResponseMsg.typecode) + return response + + # op: ScanHostPatch + def ScanHostPatch(self, request): + if isinstance(request, ScanHostPatchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ScanHostPatchResponseMsg.typecode) + return response + + # op: ScanHostPatch_Task + def ScanHostPatch_Task(self, request): + if isinstance(request, ScanHostPatch_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ScanHostPatch_TaskResponseMsg.typecode) + return response + + # op: ScanHostPatchV2 + def ScanHostPatchV2(self, request): + if isinstance(request, ScanHostPatchV2RequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ScanHostPatchV2ResponseMsg.typecode) + return response + + # op: ScanHostPatchV2_Task + def ScanHostPatchV2_Task(self, request): + if isinstance(request, ScanHostPatchV2_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ScanHostPatchV2_TaskResponseMsg.typecode) + return response + + # op: StageHostPatch + def StageHostPatch(self, request): + if isinstance(request, StageHostPatchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StageHostPatchResponseMsg.typecode) + return response + + # op: StageHostPatch_Task + def StageHostPatch_Task(self, request): + if isinstance(request, StageHostPatch_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StageHostPatch_TaskResponseMsg.typecode) + return response + + # op: InstallHostPatch + def InstallHostPatch(self, request): + if isinstance(request, InstallHostPatchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(InstallHostPatchResponseMsg.typecode) + return response + + # op: InstallHostPatch_Task + def InstallHostPatch_Task(self, request): + if isinstance(request, InstallHostPatch_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(InstallHostPatch_TaskResponseMsg.typecode) + return response + + # op: InstallHostPatchV2 + def InstallHostPatchV2(self, request): + if isinstance(request, InstallHostPatchV2RequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(InstallHostPatchV2ResponseMsg.typecode) + return response + + # op: InstallHostPatchV2_Task + def InstallHostPatchV2_Task(self, request): + if isinstance(request, InstallHostPatchV2_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(InstallHostPatchV2_TaskResponseMsg.typecode) + return response + + # op: UninstallHostPatch + def UninstallHostPatch(self, request): + if isinstance(request, UninstallHostPatchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UninstallHostPatchResponseMsg.typecode) + return response + + # op: UninstallHostPatch_Task + def UninstallHostPatch_Task(self, request): + if isinstance(request, UninstallHostPatch_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UninstallHostPatch_TaskResponseMsg.typecode) + return response + + # op: QueryHostPatch + def QueryHostPatch(self, request): + if isinstance(request, QueryHostPatchRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryHostPatchResponseMsg.typecode) + return response + + # op: QueryHostPatch_Task + def QueryHostPatch_Task(self, request): + if isinstance(request, QueryHostPatch_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryHostPatch_TaskResponseMsg.typecode) + return response + + # op: Refresh + def Refresh(self, request): + if isinstance(request, RefreshRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshResponseMsg.typecode) + return response + + # op: UpdatePassthruConfig + def UpdatePassthruConfig(self, request): + if isinstance(request, UpdatePassthruConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdatePassthruConfigResponseMsg.typecode) + return response + + # op: UpdateServicePolicy + def UpdateServicePolicy(self, request): + if isinstance(request, UpdateServicePolicyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateServicePolicyResponseMsg.typecode) + return response + + # op: StartService + def StartService(self, request): + if isinstance(request, StartServiceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StartServiceResponseMsg.typecode) + return response + + # op: StopService + def StopService(self, request): + if isinstance(request, StopServiceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(StopServiceResponseMsg.typecode) + return response + + # op: RestartService + def RestartService(self, request): + if isinstance(request, RestartServiceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RestartServiceResponseMsg.typecode) + return response + + # op: UninstallService + def UninstallService(self, request): + if isinstance(request, UninstallServiceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UninstallServiceResponseMsg.typecode) + return response + + # op: RefreshServices + def RefreshServices(self, request): + if isinstance(request, RefreshServicesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshServicesResponseMsg.typecode) + return response + + # op: ReconfigureSnmpAgent + def ReconfigureSnmpAgent(self, request): + if isinstance(request, ReconfigureSnmpAgentRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureSnmpAgentResponseMsg.typecode) + return response + + # op: SendTestNotification + def SendTestNotification(self, request): + if isinstance(request, SendTestNotificationRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SendTestNotificationResponseMsg.typecode) + return response + + # op: RetrieveDiskPartitionInfo + def RetrieveDiskPartitionInfo(self, request): + if isinstance(request, RetrieveDiskPartitionInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveDiskPartitionInfoResponseMsg.typecode) + return response + + # op: ComputeDiskPartitionInfo + def ComputeDiskPartitionInfo(self, request): + if isinstance(request, ComputeDiskPartitionInfoRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ComputeDiskPartitionInfoResponseMsg.typecode) + return response + + # op: ComputeDiskPartitionInfoForResize + def ComputeDiskPartitionInfoForResize(self, request): + if isinstance(request, ComputeDiskPartitionInfoForResizeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ComputeDiskPartitionInfoForResizeResponseMsg.typecode) + return response + + # op: UpdateDiskPartitions + def UpdateDiskPartitions(self, request): + if isinstance(request, UpdateDiskPartitionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateDiskPartitionsResponseMsg.typecode) + return response + + # op: FormatVmfs + def FormatVmfs(self, request): + if isinstance(request, FormatVmfsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(FormatVmfsResponseMsg.typecode) + return response + + # op: RescanVmfs + def RescanVmfs(self, request): + if isinstance(request, RescanVmfsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RescanVmfsResponseMsg.typecode) + return response + + # op: AttachVmfsExtent + def AttachVmfsExtent(self, request): + if isinstance(request, AttachVmfsExtentRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AttachVmfsExtentResponseMsg.typecode) + return response + + # op: ExpandVmfsExtent + def ExpandVmfsExtent(self, request): + if isinstance(request, ExpandVmfsExtentRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ExpandVmfsExtentResponseMsg.typecode) + return response + + # op: UpgradeVmfs + def UpgradeVmfs(self, request): + if isinstance(request, UpgradeVmfsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpgradeVmfsResponseMsg.typecode) + return response + + # op: UpgradeVmLayout + def UpgradeVmLayout(self, request): + if isinstance(request, UpgradeVmLayoutRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpgradeVmLayoutResponseMsg.typecode) + return response + + # op: QueryUnresolvedVmfsVolume + def QueryUnresolvedVmfsVolume(self, request): + if isinstance(request, QueryUnresolvedVmfsVolumeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryUnresolvedVmfsVolumeResponseMsg.typecode) + return response + + # op: ResolveMultipleUnresolvedVmfsVolumes + def ResolveMultipleUnresolvedVmfsVolumes(self, request): + if isinstance(request, ResolveMultipleUnresolvedVmfsVolumesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResolveMultipleUnresolvedVmfsVolumesResponseMsg.typecode) + return response + + # op: UnmountForceMountedVmfsVolume + def UnmountForceMountedVmfsVolume(self, request): + if isinstance(request, UnmountForceMountedVmfsVolumeRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UnmountForceMountedVmfsVolumeResponseMsg.typecode) + return response + + # op: RescanHba + def RescanHba(self, request): + if isinstance(request, RescanHbaRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RescanHbaResponseMsg.typecode) + return response + + # op: RescanAllHba + def RescanAllHba(self, request): + if isinstance(request, RescanAllHbaRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RescanAllHbaResponseMsg.typecode) + return response + + # op: UpdateSoftwareInternetScsiEnabled + def UpdateSoftwareInternetScsiEnabled(self, request): + if isinstance(request, UpdateSoftwareInternetScsiEnabledRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateSoftwareInternetScsiEnabledResponseMsg.typecode) + return response + + # op: UpdateInternetScsiDiscoveryProperties + def UpdateInternetScsiDiscoveryProperties(self, request): + if isinstance(request, UpdateInternetScsiDiscoveryPropertiesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateInternetScsiDiscoveryPropertiesResponseMsg.typecode) + return response + + # op: UpdateInternetScsiAuthenticationProperties + def UpdateInternetScsiAuthenticationProperties(self, request): + if isinstance(request, UpdateInternetScsiAuthenticationPropertiesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateInternetScsiAuthenticationPropertiesResponseMsg.typecode) + return response + + # op: UpdateInternetScsiDigestProperties + def UpdateInternetScsiDigestProperties(self, request): + if isinstance(request, UpdateInternetScsiDigestPropertiesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateInternetScsiDigestPropertiesResponseMsg.typecode) + return response + + # op: UpdateInternetScsiAdvancedOptions + def UpdateInternetScsiAdvancedOptions(self, request): + if isinstance(request, UpdateInternetScsiAdvancedOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateInternetScsiAdvancedOptionsResponseMsg.typecode) + return response + + # op: UpdateInternetScsiIPProperties + def UpdateInternetScsiIPProperties(self, request): + if isinstance(request, UpdateInternetScsiIPPropertiesRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateInternetScsiIPPropertiesResponseMsg.typecode) + return response + + # op: UpdateInternetScsiName + def UpdateInternetScsiName(self, request): + if isinstance(request, UpdateInternetScsiNameRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateInternetScsiNameResponseMsg.typecode) + return response + + # op: UpdateInternetScsiAlias + def UpdateInternetScsiAlias(self, request): + if isinstance(request, UpdateInternetScsiAliasRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateInternetScsiAliasResponseMsg.typecode) + return response + + # op: AddInternetScsiSendTargets + def AddInternetScsiSendTargets(self, request): + if isinstance(request, AddInternetScsiSendTargetsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddInternetScsiSendTargetsResponseMsg.typecode) + return response + + # op: RemoveInternetScsiSendTargets + def RemoveInternetScsiSendTargets(self, request): + if isinstance(request, RemoveInternetScsiSendTargetsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveInternetScsiSendTargetsResponseMsg.typecode) + return response + + # op: AddInternetScsiStaticTargets + def AddInternetScsiStaticTargets(self, request): + if isinstance(request, AddInternetScsiStaticTargetsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(AddInternetScsiStaticTargetsResponseMsg.typecode) + return response + + # op: RemoveInternetScsiStaticTargets + def RemoveInternetScsiStaticTargets(self, request): + if isinstance(request, RemoveInternetScsiStaticTargetsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveInternetScsiStaticTargetsResponseMsg.typecode) + return response + + # op: EnableMultipathPath + def EnableMultipathPath(self, request): + if isinstance(request, EnableMultipathPathRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(EnableMultipathPathResponseMsg.typecode) + return response + + # op: DisableMultipathPath + def DisableMultipathPath(self, request): + if isinstance(request, DisableMultipathPathRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DisableMultipathPathResponseMsg.typecode) + return response + + # op: SetMultipathLunPolicy + def SetMultipathLunPolicy(self, request): + if isinstance(request, SetMultipathLunPolicyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SetMultipathLunPolicyResponseMsg.typecode) + return response + + # op: QueryPathSelectionPolicyOptions + def QueryPathSelectionPolicyOptions(self, request): + if isinstance(request, QueryPathSelectionPolicyOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryPathSelectionPolicyOptionsResponseMsg.typecode) + return response + + # op: QueryStorageArrayTypePolicyOptions + def QueryStorageArrayTypePolicyOptions(self, request): + if isinstance(request, QueryStorageArrayTypePolicyOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryStorageArrayTypePolicyOptionsResponseMsg.typecode) + return response + + # op: UpdateScsiLunDisplayName + def UpdateScsiLunDisplayName(self, request): + if isinstance(request, UpdateScsiLunDisplayNameRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateScsiLunDisplayNameResponseMsg.typecode) + return response + + # op: RefreshStorageSystem + def RefreshStorageSystem(self, request): + if isinstance(request, RefreshStorageSystemRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RefreshStorageSystemResponseMsg.typecode) + return response + + # op: UpdateIpConfig + def UpdateIpConfig(self, request): + if isinstance(request, UpdateIpConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateIpConfigResponseMsg.typecode) + return response + + # op: SelectVnic + def SelectVnic(self, request): + if isinstance(request, SelectVnicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(SelectVnicResponseMsg.typecode) + return response + + # op: DeselectVnic + def DeselectVnic(self, request): + if isinstance(request, DeselectVnicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DeselectVnicResponseMsg.typecode) + return response + + # op: QueryNetConfig + def QueryNetConfig(self, request): + if isinstance(request, QueryNetConfigRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryNetConfigResponseMsg.typecode) + return response + + # op: VirtualNicManagerSelectVnic + def VirtualNicManagerSelectVnic(self, request): + if isinstance(request, VirtualNicManagerSelectVnicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(VirtualNicManagerSelectVnicResponseMsg.typecode) + return response + + # op: VirtualNicManagerDeselectVnic + def VirtualNicManagerDeselectVnic(self, request): + if isinstance(request, VirtualNicManagerDeselectVnicRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(VirtualNicManagerDeselectVnicResponseMsg.typecode) + return response + + # op: QueryOptions + def QueryOptions(self, request): + if isinstance(request, QueryOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryOptionsResponseMsg.typecode) + return response + + # op: UpdateOptions + def UpdateOptions(self, request): + if isinstance(request, UpdateOptionsRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(UpdateOptionsResponseMsg.typecode) + return response + + # op: ComplianceManagerCheckCompliance + def ComplianceManagerCheckCompliance(self, request): + if isinstance(request, ComplianceManagerCheckComplianceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ComplianceManagerCheckComplianceResponseMsg.typecode) + return response + + # op: ComplianceManagerCheckCompliance_Task + def ComplianceManagerCheckCompliance_Task(self, request): + if isinstance(request, ComplianceManagerCheckCompliance_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ComplianceManagerCheckCompliance_TaskResponseMsg.typecode) + return response + + # op: ComplianceManagerQueryComplianceStatus + def ComplianceManagerQueryComplianceStatus(self, request): + if isinstance(request, ComplianceManagerQueryComplianceStatusRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ComplianceManagerQueryComplianceStatusResponseMsg.typecode) + return response + + # op: ComplianceManagerClearComplianceStatus + def ComplianceManagerClearComplianceStatus(self, request): + if isinstance(request, ComplianceManagerClearComplianceStatusRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ComplianceManagerClearComplianceStatusResponseMsg.typecode) + return response + + # op: ComplianceManagerQueryExpressionMetadata + def ComplianceManagerQueryExpressionMetadata(self, request): + if isinstance(request, ComplianceManagerQueryExpressionMetadataRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ComplianceManagerQueryExpressionMetadataResponseMsg.typecode) + return response + + # op: ProfileDestroy + def ProfileDestroy(self, request): + if isinstance(request, ProfileDestroyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileDestroyResponseMsg.typecode) + return response + + # op: ProfileAssociate + def ProfileAssociate(self, request): + if isinstance(request, ProfileAssociateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileAssociateResponseMsg.typecode) + return response + + # op: ProfileDissociate + def ProfileDissociate(self, request): + if isinstance(request, ProfileDissociateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileDissociateResponseMsg.typecode) + return response + + # op: ProfileCheckCompliance + def ProfileCheckCompliance(self, request): + if isinstance(request, ProfileCheckComplianceRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileCheckComplianceResponseMsg.typecode) + return response + + # op: ProfileCheckCompliance_Task + def ProfileCheckCompliance_Task(self, request): + if isinstance(request, ProfileCheckCompliance_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileCheckCompliance_TaskResponseMsg.typecode) + return response + + # op: ProfileExportProfile + def ProfileExportProfile(self, request): + if isinstance(request, ProfileExportProfileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileExportProfileResponseMsg.typecode) + return response + + # op: CreateProfile + def CreateProfile(self, request): + if isinstance(request, CreateProfileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateProfileResponseMsg.typecode) + return response + + # op: ProfileQueryPolicyMetadata + def ProfileQueryPolicyMetadata(self, request): + if isinstance(request, ProfileQueryPolicyMetadataRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileQueryPolicyMetadataResponseMsg.typecode) + return response + + # op: ProfileFindAssociatedProfile + def ProfileFindAssociatedProfile(self, request): + if isinstance(request, ProfileFindAssociatedProfileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ProfileFindAssociatedProfileResponseMsg.typecode) + return response + + # op: ClusterProfileUpdate + def ClusterProfileUpdate(self, request): + if isinstance(request, ClusterProfileUpdateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ClusterProfileUpdateResponseMsg.typecode) + return response + + # op: HostProfileUpdateReferenceHost + def HostProfileUpdateReferenceHost(self, request): + if isinstance(request, HostProfileUpdateReferenceHostRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileUpdateReferenceHostResponseMsg.typecode) + return response + + # op: HostProfileUpdate + def HostProfileUpdate(self, request): + if isinstance(request, HostProfileUpdateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileUpdateResponseMsg.typecode) + return response + + # op: HostProfileExecute + def HostProfileExecute(self, request): + if isinstance(request, HostProfileExecuteRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileExecuteResponseMsg.typecode) + return response + + # op: HostProfileApply + def HostProfileApply(self, request): + if isinstance(request, HostProfileApplyRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileApplyResponseMsg.typecode) + return response + + # op: HostProfileApply_Task + def HostProfileApply_Task(self, request): + if isinstance(request, HostProfileApply_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileApply_TaskResponseMsg.typecode) + return response + + # op: HostProfileGenerateConfigTaskList + def HostProfileGenerateConfigTaskList(self, request): + if isinstance(request, HostProfileGenerateConfigTaskListRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileGenerateConfigTaskListResponseMsg.typecode) + return response + + # op: HostProfileQueryProfileMetadata + def HostProfileQueryProfileMetadata(self, request): + if isinstance(request, HostProfileQueryProfileMetadataRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileQueryProfileMetadataResponseMsg.typecode) + return response + + # op: HostProfileCreateDefaultProfile + def HostProfileCreateDefaultProfile(self, request): + if isinstance(request, HostProfileCreateDefaultProfileRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(HostProfileCreateDefaultProfileResponseMsg.typecode) + return response + + # op: RemoveScheduledTask + def RemoveScheduledTask(self, request): + if isinstance(request, RemoveScheduledTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveScheduledTaskResponseMsg.typecode) + return response + + # op: ReconfigureScheduledTask + def ReconfigureScheduledTask(self, request): + if isinstance(request, ReconfigureScheduledTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ReconfigureScheduledTaskResponseMsg.typecode) + return response + + # op: RunScheduledTask + def RunScheduledTask(self, request): + if isinstance(request, RunScheduledTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RunScheduledTaskResponseMsg.typecode) + return response + + # op: CreateScheduledTask + def CreateScheduledTask(self, request): + if isinstance(request, CreateScheduledTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateScheduledTaskResponseMsg.typecode) + return response + + # op: RetrieveEntityScheduledTask + def RetrieveEntityScheduledTask(self, request): + if isinstance(request, RetrieveEntityScheduledTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveEntityScheduledTaskResponseMsg.typecode) + return response + + # op: CreateObjectScheduledTask + def CreateObjectScheduledTask(self, request): + if isinstance(request, CreateObjectScheduledTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateObjectScheduledTaskResponseMsg.typecode) + return response + + # op: RetrieveObjectScheduledTask + def RetrieveObjectScheduledTask(self, request): + if isinstance(request, RetrieveObjectScheduledTaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RetrieveObjectScheduledTaskResponseMsg.typecode) + return response + + # op: OpenInventoryViewFolder + def OpenInventoryViewFolder(self, request): + if isinstance(request, OpenInventoryViewFolderRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(OpenInventoryViewFolderResponseMsg.typecode) + return response + + # op: CloseInventoryViewFolder + def CloseInventoryViewFolder(self, request): + if isinstance(request, CloseInventoryViewFolderRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CloseInventoryViewFolderResponseMsg.typecode) + return response + + # op: ModifyListView + def ModifyListView(self, request): + if isinstance(request, ModifyListViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ModifyListViewResponseMsg.typecode) + return response + + # op: ResetListView + def ResetListView(self, request): + if isinstance(request, ResetListViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetListViewResponseMsg.typecode) + return response + + # op: ResetListViewFromView + def ResetListViewFromView(self, request): + if isinstance(request, ResetListViewFromViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(ResetListViewFromViewResponseMsg.typecode) + return response + + # op: DestroyView + def DestroyView(self, request): + if isinstance(request, DestroyViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(DestroyViewResponseMsg.typecode) + return response + + # op: CreateInventoryView + def CreateInventoryView(self, request): + if isinstance(request, CreateInventoryViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateInventoryViewResponseMsg.typecode) + return response + + # op: CreateContainerView + def CreateContainerView(self, request): + if isinstance(request, CreateContainerViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateContainerViewResponseMsg.typecode) + return response + + # op: CreateListView + def CreateListView(self, request): + if isinstance(request, CreateListViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateListViewResponseMsg.typecode) + return response + + # op: CreateListViewFromView + def CreateListViewFromView(self, request): + if isinstance(request, CreateListViewFromViewRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CreateListViewFromViewResponseMsg.typecode) + return response + + # op: RevertToSnapshot + def RevertToSnapshot(self, request): + if isinstance(request, RevertToSnapshotRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RevertToSnapshotResponseMsg.typecode) + return response + + # op: RevertToSnapshot_Task + def RevertToSnapshot_Task(self, request): + if isinstance(request, RevertToSnapshot_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RevertToSnapshot_TaskResponseMsg.typecode) + return response + + # op: RemoveSnapshot + def RemoveSnapshot(self, request): + if isinstance(request, RemoveSnapshotRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveSnapshotResponseMsg.typecode) + return response + + # op: RemoveSnapshot_Task + def RemoveSnapshot_Task(self, request): + if isinstance(request, RemoveSnapshot_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RemoveSnapshot_TaskResponseMsg.typecode) + return response + + # op: RenameSnapshot + def RenameSnapshot(self, request): + if isinstance(request, RenameSnapshotRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(RenameSnapshotResponseMsg.typecode) + return response + + # op: CheckCompatibility + def CheckCompatibility(self, request): + if isinstance(request, CheckCompatibilityRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckCompatibilityResponseMsg.typecode) + return response + + # op: CheckCompatibility_Task + def CheckCompatibility_Task(self, request): + if isinstance(request, CheckCompatibility_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckCompatibility_TaskResponseMsg.typecode) + return response + + # op: QueryVMotionCompatibilityEx + def QueryVMotionCompatibilityEx(self, request): + if isinstance(request, QueryVMotionCompatibilityExRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVMotionCompatibilityExResponseMsg.typecode) + return response + + # op: QueryVMotionCompatibilityEx_Task + def QueryVMotionCompatibilityEx_Task(self, request): + if isinstance(request, QueryVMotionCompatibilityEx_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(QueryVMotionCompatibilityEx_TaskResponseMsg.typecode) + return response + + # op: CheckMigrate + def CheckMigrate(self, request): + if isinstance(request, CheckMigrateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckMigrateResponseMsg.typecode) + return response + + # op: CheckMigrate_Task + def CheckMigrate_Task(self, request): + if isinstance(request, CheckMigrate_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckMigrate_TaskResponseMsg.typecode) + return response + + # op: CheckRelocate + def CheckRelocate(self, request): + if isinstance(request, CheckRelocateRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckRelocateResponseMsg.typecode) + return response + + # op: CheckRelocate_Task + def CheckRelocate_Task(self, request): + if isinstance(request, CheckRelocate_TaskRequestMsg) is False: + raise TypeError, "%s incorrect request type" % (request.__class__) + kw = {} + # no input wsaction + self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) + # no output wsaction + response = self.binding.Receive(CheckRelocate_TaskResponseMsg.typecode) + return response + +DestroyPropertyFilterRequestMsg = ns0.DestroyPropertyFilter_Dec().pyclass + +DestroyPropertyFilterResponseMsg = ns0.DestroyPropertyFilterResponse_Dec().pyclass + +CreateFilterRequestMsg = ns0.CreateFilter_Dec().pyclass + +CreateFilterResponseMsg = ns0.CreateFilterResponse_Dec().pyclass + +RetrievePropertiesRequestMsg = ns0.RetrieveProperties_Dec().pyclass + +RetrievePropertiesResponseMsg = ns0.RetrievePropertiesResponse_Dec().pyclass + +CheckForUpdatesRequestMsg = ns0.CheckForUpdates_Dec().pyclass + +CheckForUpdatesResponseMsg = ns0.CheckForUpdatesResponse_Dec().pyclass + +WaitForUpdatesRequestMsg = ns0.WaitForUpdates_Dec().pyclass + +WaitForUpdatesResponseMsg = ns0.WaitForUpdatesResponse_Dec().pyclass + +CancelWaitForUpdatesRequestMsg = ns0.CancelWaitForUpdates_Dec().pyclass + +CancelWaitForUpdatesResponseMsg = ns0.CancelWaitForUpdatesResponse_Dec().pyclass + +AddAuthorizationRoleRequestMsg = ns0.AddAuthorizationRole_Dec().pyclass + +AddAuthorizationRoleResponseMsg = ns0.AddAuthorizationRoleResponse_Dec().pyclass + +RemoveAuthorizationRoleRequestMsg = ns0.RemoveAuthorizationRole_Dec().pyclass + +RemoveAuthorizationRoleResponseMsg = ns0.RemoveAuthorizationRoleResponse_Dec().pyclass + +UpdateAuthorizationRoleRequestMsg = ns0.UpdateAuthorizationRole_Dec().pyclass + +UpdateAuthorizationRoleResponseMsg = ns0.UpdateAuthorizationRoleResponse_Dec().pyclass + +MergePermissionsRequestMsg = ns0.MergePermissions_Dec().pyclass + +MergePermissionsResponseMsg = ns0.MergePermissionsResponse_Dec().pyclass + +RetrieveRolePermissionsRequestMsg = ns0.RetrieveRolePermissions_Dec().pyclass + +RetrieveRolePermissionsResponseMsg = ns0.RetrieveRolePermissionsResponse_Dec().pyclass + +RetrieveEntityPermissionsRequestMsg = ns0.RetrieveEntityPermissions_Dec().pyclass + +RetrieveEntityPermissionsResponseMsg = ns0.RetrieveEntityPermissionsResponse_Dec().pyclass + +RetrieveAllPermissionsRequestMsg = ns0.RetrieveAllPermissions_Dec().pyclass + +RetrieveAllPermissionsResponseMsg = ns0.RetrieveAllPermissionsResponse_Dec().pyclass + +SetEntityPermissionsRequestMsg = ns0.SetEntityPermissions_Dec().pyclass + +SetEntityPermissionsResponseMsg = ns0.SetEntityPermissionsResponse_Dec().pyclass + +ResetEntityPermissionsRequestMsg = ns0.ResetEntityPermissions_Dec().pyclass + +ResetEntityPermissionsResponseMsg = ns0.ResetEntityPermissionsResponse_Dec().pyclass + +RemoveEntityPermissionRequestMsg = ns0.RemoveEntityPermission_Dec().pyclass + +RemoveEntityPermissionResponseMsg = ns0.RemoveEntityPermissionResponse_Dec().pyclass + +ReconfigureClusterRequestMsg = ns0.ReconfigureCluster_Dec().pyclass + +ReconfigureClusterResponseMsg = ns0.ReconfigureClusterResponse_Dec().pyclass + +ReconfigureCluster_TaskRequestMsg = ns0.ReconfigureCluster_Task_Dec().pyclass + +ReconfigureCluster_TaskResponseMsg = ns0.ReconfigureCluster_TaskResponse_Dec().pyclass + +ApplyRecommendationRequestMsg = ns0.ApplyRecommendation_Dec().pyclass + +ApplyRecommendationResponseMsg = ns0.ApplyRecommendationResponse_Dec().pyclass + +RecommendHostsForVmRequestMsg = ns0.RecommendHostsForVm_Dec().pyclass + +RecommendHostsForVmResponseMsg = ns0.RecommendHostsForVmResponse_Dec().pyclass + +AddHostRequestMsg = ns0.AddHost_Dec().pyclass + +AddHostResponseMsg = ns0.AddHostResponse_Dec().pyclass + +AddHost_TaskRequestMsg = ns0.AddHost_Task_Dec().pyclass + +AddHost_TaskResponseMsg = ns0.AddHost_TaskResponse_Dec().pyclass + +MoveIntoRequestMsg = ns0.MoveInto_Dec().pyclass + +MoveIntoResponseMsg = ns0.MoveIntoResponse_Dec().pyclass + +MoveInto_TaskRequestMsg = ns0.MoveInto_Task_Dec().pyclass + +MoveInto_TaskResponseMsg = ns0.MoveInto_TaskResponse_Dec().pyclass + +MoveHostIntoRequestMsg = ns0.MoveHostInto_Dec().pyclass + +MoveHostIntoResponseMsg = ns0.MoveHostIntoResponse_Dec().pyclass + +MoveHostInto_TaskRequestMsg = ns0.MoveHostInto_Task_Dec().pyclass + +MoveHostInto_TaskResponseMsg = ns0.MoveHostInto_TaskResponse_Dec().pyclass + +RefreshRecommendationRequestMsg = ns0.RefreshRecommendation_Dec().pyclass + +RefreshRecommendationResponseMsg = ns0.RefreshRecommendationResponse_Dec().pyclass + +RetrieveDasAdvancedRuntimeInfoRequestMsg = ns0.RetrieveDasAdvancedRuntimeInfo_Dec().pyclass + +RetrieveDasAdvancedRuntimeInfoResponseMsg = ns0.RetrieveDasAdvancedRuntimeInfoResponse_Dec().pyclass + +ReconfigureComputeResourceRequestMsg = ns0.ReconfigureComputeResource_Dec().pyclass + +ReconfigureComputeResourceResponseMsg = ns0.ReconfigureComputeResourceResponse_Dec().pyclass + +ReconfigureComputeResource_TaskRequestMsg = ns0.ReconfigureComputeResource_Task_Dec().pyclass + +ReconfigureComputeResource_TaskResponseMsg = ns0.ReconfigureComputeResource_TaskResponse_Dec().pyclass + +AddCustomFieldDefRequestMsg = ns0.AddCustomFieldDef_Dec().pyclass + +AddCustomFieldDefResponseMsg = ns0.AddCustomFieldDefResponse_Dec().pyclass + +RemoveCustomFieldDefRequestMsg = ns0.RemoveCustomFieldDef_Dec().pyclass + +RemoveCustomFieldDefResponseMsg = ns0.RemoveCustomFieldDefResponse_Dec().pyclass + +RenameCustomFieldDefRequestMsg = ns0.RenameCustomFieldDef_Dec().pyclass + +RenameCustomFieldDefResponseMsg = ns0.RenameCustomFieldDefResponse_Dec().pyclass + +SetFieldRequestMsg = ns0.SetField_Dec().pyclass + +SetFieldResponseMsg = ns0.SetFieldResponse_Dec().pyclass + +DoesCustomizationSpecExistRequestMsg = ns0.DoesCustomizationSpecExist_Dec().pyclass + +DoesCustomizationSpecExistResponseMsg = ns0.DoesCustomizationSpecExistResponse_Dec().pyclass + +GetCustomizationSpecRequestMsg = ns0.GetCustomizationSpec_Dec().pyclass + +GetCustomizationSpecResponseMsg = ns0.GetCustomizationSpecResponse_Dec().pyclass + +CreateCustomizationSpecRequestMsg = ns0.CreateCustomizationSpec_Dec().pyclass + +CreateCustomizationSpecResponseMsg = ns0.CreateCustomizationSpecResponse_Dec().pyclass + +OverwriteCustomizationSpecRequestMsg = ns0.OverwriteCustomizationSpec_Dec().pyclass + +OverwriteCustomizationSpecResponseMsg = ns0.OverwriteCustomizationSpecResponse_Dec().pyclass + +DeleteCustomizationSpecRequestMsg = ns0.DeleteCustomizationSpec_Dec().pyclass + +DeleteCustomizationSpecResponseMsg = ns0.DeleteCustomizationSpecResponse_Dec().pyclass + +DuplicateCustomizationSpecRequestMsg = ns0.DuplicateCustomizationSpec_Dec().pyclass + +DuplicateCustomizationSpecResponseMsg = ns0.DuplicateCustomizationSpecResponse_Dec().pyclass + +RenameCustomizationSpecRequestMsg = ns0.RenameCustomizationSpec_Dec().pyclass + +RenameCustomizationSpecResponseMsg = ns0.RenameCustomizationSpecResponse_Dec().pyclass + +CustomizationSpecItemToXmlRequestMsg = ns0.CustomizationSpecItemToXml_Dec().pyclass + +CustomizationSpecItemToXmlResponseMsg = ns0.CustomizationSpecItemToXmlResponse_Dec().pyclass + +XmlToCustomizationSpecItemRequestMsg = ns0.XmlToCustomizationSpecItem_Dec().pyclass + +XmlToCustomizationSpecItemResponseMsg = ns0.XmlToCustomizationSpecItemResponse_Dec().pyclass + +CheckCustomizationResourcesRequestMsg = ns0.CheckCustomizationResources_Dec().pyclass + +CheckCustomizationResourcesResponseMsg = ns0.CheckCustomizationResourcesResponse_Dec().pyclass + +QueryConnectionInfoRequestMsg = ns0.QueryConnectionInfo_Dec().pyclass + +QueryConnectionInfoResponseMsg = ns0.QueryConnectionInfoResponse_Dec().pyclass + +PowerOnMultiVMRequestMsg = ns0.PowerOnMultiVM_Dec().pyclass + +PowerOnMultiVMResponseMsg = ns0.PowerOnMultiVMResponse_Dec().pyclass + +PowerOnMultiVM_TaskRequestMsg = ns0.PowerOnMultiVM_Task_Dec().pyclass + +PowerOnMultiVM_TaskResponseMsg = ns0.PowerOnMultiVM_TaskResponse_Dec().pyclass + +RefreshDatastoreRequestMsg = ns0.RefreshDatastore_Dec().pyclass + +RefreshDatastoreResponseMsg = ns0.RefreshDatastoreResponse_Dec().pyclass + +RefreshDatastoreStorageInfoRequestMsg = ns0.RefreshDatastoreStorageInfo_Dec().pyclass + +RefreshDatastoreStorageInfoResponseMsg = ns0.RefreshDatastoreStorageInfoResponse_Dec().pyclass + +RenameDatastoreRequestMsg = ns0.RenameDatastore_Dec().pyclass + +RenameDatastoreResponseMsg = ns0.RenameDatastoreResponse_Dec().pyclass + +DestroyDatastoreRequestMsg = ns0.DestroyDatastore_Dec().pyclass + +DestroyDatastoreResponseMsg = ns0.DestroyDatastoreResponse_Dec().pyclass + +QueryDescriptionsRequestMsg = ns0.QueryDescriptions_Dec().pyclass + +QueryDescriptionsResponseMsg = ns0.QueryDescriptionsResponse_Dec().pyclass + +BrowseDiagnosticLogRequestMsg = ns0.BrowseDiagnosticLog_Dec().pyclass + +BrowseDiagnosticLogResponseMsg = ns0.BrowseDiagnosticLogResponse_Dec().pyclass + +GenerateLogBundlesRequestMsg = ns0.GenerateLogBundles_Dec().pyclass + +GenerateLogBundlesResponseMsg = ns0.GenerateLogBundlesResponse_Dec().pyclass + +GenerateLogBundles_TaskRequestMsg = ns0.GenerateLogBundles_Task_Dec().pyclass + +GenerateLogBundles_TaskResponseMsg = ns0.GenerateLogBundles_TaskResponse_Dec().pyclass + +DVSFetchKeyOfPortsRequestMsg = ns0.DVSFetchKeyOfPorts_Dec().pyclass + +DVSFetchKeyOfPortsResponseMsg = ns0.DVSFetchKeyOfPortsResponse_Dec().pyclass + +DVSFetchPortsRequestMsg = ns0.DVSFetchPorts_Dec().pyclass + +DVSFetchPortsResponseMsg = ns0.DVSFetchPortsResponse_Dec().pyclass + +DVSQueryUsedVlanIdRequestMsg = ns0.DVSQueryUsedVlanId_Dec().pyclass + +DVSQueryUsedVlanIdResponseMsg = ns0.DVSQueryUsedVlanIdResponse_Dec().pyclass + +DVSReconfigureRequestMsg = ns0.DVSReconfigure_Dec().pyclass + +DVSReconfigureResponseMsg = ns0.DVSReconfigureResponse_Dec().pyclass + +DVSReconfigure_TaskRequestMsg = ns0.DVSReconfigure_Task_Dec().pyclass + +DVSReconfigure_TaskResponseMsg = ns0.DVSReconfigure_TaskResponse_Dec().pyclass + +DVSPerformProductSpecOperationRequestMsg = ns0.DVSPerformProductSpecOperation_Dec().pyclass + +DVSPerformProductSpecOperationResponseMsg = ns0.DVSPerformProductSpecOperationResponse_Dec().pyclass + +DVSPerformProductSpecOperation_TaskRequestMsg = ns0.DVSPerformProductSpecOperation_Task_Dec().pyclass + +DVSPerformProductSpecOperation_TaskResponseMsg = ns0.DVSPerformProductSpecOperation_TaskResponse_Dec().pyclass + +DVSMergeRequestMsg = ns0.DVSMerge_Dec().pyclass + +DVSMergeResponseMsg = ns0.DVSMergeResponse_Dec().pyclass + +DVSMerge_TaskRequestMsg = ns0.DVSMerge_Task_Dec().pyclass + +DVSMerge_TaskResponseMsg = ns0.DVSMerge_TaskResponse_Dec().pyclass + +DVSAddPortgroupsRequestMsg = ns0.DVSAddPortgroups_Dec().pyclass + +DVSAddPortgroupsResponseMsg = ns0.DVSAddPortgroupsResponse_Dec().pyclass + +DVSMovePortRequestMsg = ns0.DVSMovePort_Dec().pyclass + +DVSMovePortResponseMsg = ns0.DVSMovePortResponse_Dec().pyclass + +DVSUpdateCapabilityRequestMsg = ns0.DVSUpdateCapability_Dec().pyclass + +DVSUpdateCapabilityResponseMsg = ns0.DVSUpdateCapabilityResponse_Dec().pyclass + +ReconfigurePortRequestMsg = ns0.ReconfigurePort_Dec().pyclass + +ReconfigurePortResponseMsg = ns0.ReconfigurePortResponse_Dec().pyclass + +DVSRefreshPortStateRequestMsg = ns0.DVSRefreshPortState_Dec().pyclass + +DVSRefreshPortStateResponseMsg = ns0.DVSRefreshPortStateResponse_Dec().pyclass + +DVSRectifyHostRequestMsg = ns0.DVSRectifyHost_Dec().pyclass + +DVSRectifyHostResponseMsg = ns0.DVSRectifyHostResponse_Dec().pyclass + +QueryConfigOptionDescriptorRequestMsg = ns0.QueryConfigOptionDescriptor_Dec().pyclass + +QueryConfigOptionDescriptorResponseMsg = ns0.QueryConfigOptionDescriptorResponse_Dec().pyclass + +QueryConfigOptionRequestMsg = ns0.QueryConfigOption_Dec().pyclass + +QueryConfigOptionResponseMsg = ns0.QueryConfigOptionResponse_Dec().pyclass + +QueryConfigTargetRequestMsg = ns0.QueryConfigTarget_Dec().pyclass + +QueryConfigTargetResponseMsg = ns0.QueryConfigTargetResponse_Dec().pyclass + +QueryTargetCapabilitiesRequestMsg = ns0.QueryTargetCapabilities_Dec().pyclass + +QueryTargetCapabilitiesResponseMsg = ns0.QueryTargetCapabilitiesResponse_Dec().pyclass + +setCustomValueRequestMsg = ns0.setCustomValue_Dec().pyclass + +setCustomValueResponseMsg = ns0.setCustomValueResponse_Dec().pyclass + +UnregisterExtensionRequestMsg = ns0.UnregisterExtension_Dec().pyclass + +UnregisterExtensionResponseMsg = ns0.UnregisterExtensionResponse_Dec().pyclass + +FindExtensionRequestMsg = ns0.FindExtension_Dec().pyclass + +FindExtensionResponseMsg = ns0.FindExtensionResponse_Dec().pyclass + +RegisterExtensionRequestMsg = ns0.RegisterExtension_Dec().pyclass + +RegisterExtensionResponseMsg = ns0.RegisterExtensionResponse_Dec().pyclass + +UpdateExtensionRequestMsg = ns0.UpdateExtension_Dec().pyclass + +UpdateExtensionResponseMsg = ns0.UpdateExtensionResponse_Dec().pyclass + +GetPublicKeyRequestMsg = ns0.GetPublicKey_Dec().pyclass + +GetPublicKeyResponseMsg = ns0.GetPublicKeyResponse_Dec().pyclass + +SetPublicKeyRequestMsg = ns0.SetPublicKey_Dec().pyclass + +SetPublicKeyResponseMsg = ns0.SetPublicKeyResponse_Dec().pyclass + +MoveDatastoreFileRequestMsg = ns0.MoveDatastoreFile_Dec().pyclass + +MoveDatastoreFileResponseMsg = ns0.MoveDatastoreFileResponse_Dec().pyclass + +MoveDatastoreFile_TaskRequestMsg = ns0.MoveDatastoreFile_Task_Dec().pyclass + +MoveDatastoreFile_TaskResponseMsg = ns0.MoveDatastoreFile_TaskResponse_Dec().pyclass + +CopyDatastoreFileRequestMsg = ns0.CopyDatastoreFile_Dec().pyclass + +CopyDatastoreFileResponseMsg = ns0.CopyDatastoreFileResponse_Dec().pyclass + +CopyDatastoreFile_TaskRequestMsg = ns0.CopyDatastoreFile_Task_Dec().pyclass + +CopyDatastoreFile_TaskResponseMsg = ns0.CopyDatastoreFile_TaskResponse_Dec().pyclass + +DeleteDatastoreFileRequestMsg = ns0.DeleteDatastoreFile_Dec().pyclass + +DeleteDatastoreFileResponseMsg = ns0.DeleteDatastoreFileResponse_Dec().pyclass + +DeleteDatastoreFile_TaskRequestMsg = ns0.DeleteDatastoreFile_Task_Dec().pyclass + +DeleteDatastoreFile_TaskResponseMsg = ns0.DeleteDatastoreFile_TaskResponse_Dec().pyclass + +MakeDirectoryRequestMsg = ns0.MakeDirectory_Dec().pyclass + +MakeDirectoryResponseMsg = ns0.MakeDirectoryResponse_Dec().pyclass + +ChangeOwnerRequestMsg = ns0.ChangeOwner_Dec().pyclass + +ChangeOwnerResponseMsg = ns0.ChangeOwnerResponse_Dec().pyclass + +CreateFolderRequestMsg = ns0.CreateFolder_Dec().pyclass + +CreateFolderResponseMsg = ns0.CreateFolderResponse_Dec().pyclass + +MoveIntoFolderRequestMsg = ns0.MoveIntoFolder_Dec().pyclass + +MoveIntoFolderResponseMsg = ns0.MoveIntoFolderResponse_Dec().pyclass + +MoveIntoFolder_TaskRequestMsg = ns0.MoveIntoFolder_Task_Dec().pyclass + +MoveIntoFolder_TaskResponseMsg = ns0.MoveIntoFolder_TaskResponse_Dec().pyclass + +CreateVMRequestMsg = ns0.CreateVM_Dec().pyclass + +CreateVMResponseMsg = ns0.CreateVMResponse_Dec().pyclass + +CreateVM_TaskRequestMsg = ns0.CreateVM_Task_Dec().pyclass + +CreateVM_TaskResponseMsg = ns0.CreateVM_TaskResponse_Dec().pyclass + +RegisterVMRequestMsg = ns0.RegisterVM_Dec().pyclass + +RegisterVMResponseMsg = ns0.RegisterVMResponse_Dec().pyclass + +RegisterVM_TaskRequestMsg = ns0.RegisterVM_Task_Dec().pyclass + +RegisterVM_TaskResponseMsg = ns0.RegisterVM_TaskResponse_Dec().pyclass + +CreateClusterRequestMsg = ns0.CreateCluster_Dec().pyclass + +CreateClusterResponseMsg = ns0.CreateClusterResponse_Dec().pyclass + +CreateClusterExRequestMsg = ns0.CreateClusterEx_Dec().pyclass + +CreateClusterExResponseMsg = ns0.CreateClusterExResponse_Dec().pyclass + +AddStandaloneHostRequestMsg = ns0.AddStandaloneHost_Dec().pyclass + +AddStandaloneHostResponseMsg = ns0.AddStandaloneHostResponse_Dec().pyclass + +AddStandaloneHost_TaskRequestMsg = ns0.AddStandaloneHost_Task_Dec().pyclass + +AddStandaloneHost_TaskResponseMsg = ns0.AddStandaloneHost_TaskResponse_Dec().pyclass + +CreateDatacenterRequestMsg = ns0.CreateDatacenter_Dec().pyclass + +CreateDatacenterResponseMsg = ns0.CreateDatacenterResponse_Dec().pyclass + +UnregisterAndDestroyRequestMsg = ns0.UnregisterAndDestroy_Dec().pyclass + +UnregisterAndDestroyResponseMsg = ns0.UnregisterAndDestroyResponse_Dec().pyclass + +UnregisterAndDestroy_TaskRequestMsg = ns0.UnregisterAndDestroy_Task_Dec().pyclass + +UnregisterAndDestroy_TaskResponseMsg = ns0.UnregisterAndDestroy_TaskResponse_Dec().pyclass + +FolderCreateDVSRequestMsg = ns0.FolderCreateDVS_Dec().pyclass + +FolderCreateDVSResponseMsg = ns0.FolderCreateDVSResponse_Dec().pyclass + +SetCollectorPageSizeRequestMsg = ns0.SetCollectorPageSize_Dec().pyclass + +SetCollectorPageSizeResponseMsg = ns0.SetCollectorPageSizeResponse_Dec().pyclass + +RewindCollectorRequestMsg = ns0.RewindCollector_Dec().pyclass + +RewindCollectorResponseMsg = ns0.RewindCollectorResponse_Dec().pyclass + +ResetCollectorRequestMsg = ns0.ResetCollector_Dec().pyclass + +ResetCollectorResponseMsg = ns0.ResetCollectorResponse_Dec().pyclass + +DestroyCollectorRequestMsg = ns0.DestroyCollector_Dec().pyclass + +DestroyCollectorResponseMsg = ns0.DestroyCollectorResponse_Dec().pyclass + +QueryHostConnectionInfoRequestMsg = ns0.QueryHostConnectionInfo_Dec().pyclass + +QueryHostConnectionInfoResponseMsg = ns0.QueryHostConnectionInfoResponse_Dec().pyclass + +UpdateSystemResourcesRequestMsg = ns0.UpdateSystemResources_Dec().pyclass + +UpdateSystemResourcesResponseMsg = ns0.UpdateSystemResourcesResponse_Dec().pyclass + +ReconnectHostRequestMsg = ns0.ReconnectHost_Dec().pyclass + +ReconnectHostResponseMsg = ns0.ReconnectHostResponse_Dec().pyclass + +ReconnectHost_TaskRequestMsg = ns0.ReconnectHost_Task_Dec().pyclass + +ReconnectHost_TaskResponseMsg = ns0.ReconnectHost_TaskResponse_Dec().pyclass + +DisconnectHostRequestMsg = ns0.DisconnectHost_Dec().pyclass + +DisconnectHostResponseMsg = ns0.DisconnectHostResponse_Dec().pyclass + +DisconnectHost_TaskRequestMsg = ns0.DisconnectHost_Task_Dec().pyclass + +DisconnectHost_TaskResponseMsg = ns0.DisconnectHost_TaskResponse_Dec().pyclass + +EnterMaintenanceModeRequestMsg = ns0.EnterMaintenanceMode_Dec().pyclass + +EnterMaintenanceModeResponseMsg = ns0.EnterMaintenanceModeResponse_Dec().pyclass + +EnterMaintenanceMode_TaskRequestMsg = ns0.EnterMaintenanceMode_Task_Dec().pyclass + +EnterMaintenanceMode_TaskResponseMsg = ns0.EnterMaintenanceMode_TaskResponse_Dec().pyclass + +ExitMaintenanceModeRequestMsg = ns0.ExitMaintenanceMode_Dec().pyclass + +ExitMaintenanceModeResponseMsg = ns0.ExitMaintenanceModeResponse_Dec().pyclass + +ExitMaintenanceMode_TaskRequestMsg = ns0.ExitMaintenanceMode_Task_Dec().pyclass + +ExitMaintenanceMode_TaskResponseMsg = ns0.ExitMaintenanceMode_TaskResponse_Dec().pyclass + +RebootHostRequestMsg = ns0.RebootHost_Dec().pyclass + +RebootHostResponseMsg = ns0.RebootHostResponse_Dec().pyclass + +RebootHost_TaskRequestMsg = ns0.RebootHost_Task_Dec().pyclass + +RebootHost_TaskResponseMsg = ns0.RebootHost_TaskResponse_Dec().pyclass + +ShutdownHostRequestMsg = ns0.ShutdownHost_Dec().pyclass + +ShutdownHostResponseMsg = ns0.ShutdownHostResponse_Dec().pyclass + +ShutdownHost_TaskRequestMsg = ns0.ShutdownHost_Task_Dec().pyclass + +ShutdownHost_TaskResponseMsg = ns0.ShutdownHost_TaskResponse_Dec().pyclass + +PowerDownHostToStandByRequestMsg = ns0.PowerDownHostToStandBy_Dec().pyclass + +PowerDownHostToStandByResponseMsg = ns0.PowerDownHostToStandByResponse_Dec().pyclass + +PowerDownHostToStandBy_TaskRequestMsg = ns0.PowerDownHostToStandBy_Task_Dec().pyclass + +PowerDownHostToStandBy_TaskResponseMsg = ns0.PowerDownHostToStandBy_TaskResponse_Dec().pyclass + +PowerUpHostFromStandByRequestMsg = ns0.PowerUpHostFromStandBy_Dec().pyclass + +PowerUpHostFromStandByResponseMsg = ns0.PowerUpHostFromStandByResponse_Dec().pyclass + +PowerUpHostFromStandBy_TaskRequestMsg = ns0.PowerUpHostFromStandBy_Task_Dec().pyclass + +PowerUpHostFromStandBy_TaskResponseMsg = ns0.PowerUpHostFromStandBy_TaskResponse_Dec().pyclass + +QueryMemoryOverheadRequestMsg = ns0.QueryMemoryOverhead_Dec().pyclass + +QueryMemoryOverheadResponseMsg = ns0.QueryMemoryOverheadResponse_Dec().pyclass + +QueryMemoryOverheadExRequestMsg = ns0.QueryMemoryOverheadEx_Dec().pyclass + +QueryMemoryOverheadExResponseMsg = ns0.QueryMemoryOverheadExResponse_Dec().pyclass + +ReconfigureHostForDASRequestMsg = ns0.ReconfigureHostForDAS_Dec().pyclass + +ReconfigureHostForDASResponseMsg = ns0.ReconfigureHostForDASResponse_Dec().pyclass + +ReconfigureHostForDAS_TaskRequestMsg = ns0.ReconfigureHostForDAS_Task_Dec().pyclass + +ReconfigureHostForDAS_TaskResponseMsg = ns0.ReconfigureHostForDAS_TaskResponse_Dec().pyclass + +UpdateFlagsRequestMsg = ns0.UpdateFlags_Dec().pyclass + +UpdateFlagsResponseMsg = ns0.UpdateFlagsResponse_Dec().pyclass + +AcquireCimServicesTicketRequestMsg = ns0.AcquireCimServicesTicket_Dec().pyclass + +AcquireCimServicesTicketResponseMsg = ns0.AcquireCimServicesTicketResponse_Dec().pyclass + +UpdateIpmiRequestMsg = ns0.UpdateIpmi_Dec().pyclass + +UpdateIpmiResponseMsg = ns0.UpdateIpmiResponse_Dec().pyclass + +HttpNfcLeaseCompleteRequestMsg = ns0.HttpNfcLeaseComplete_Dec().pyclass + +HttpNfcLeaseCompleteResponseMsg = ns0.HttpNfcLeaseCompleteResponse_Dec().pyclass + +HttpNfcLeaseAbortRequestMsg = ns0.HttpNfcLeaseAbort_Dec().pyclass + +HttpNfcLeaseAbortResponseMsg = ns0.HttpNfcLeaseAbortResponse_Dec().pyclass + +HttpNfcLeaseProgressRequestMsg = ns0.HttpNfcLeaseProgress_Dec().pyclass + +HttpNfcLeaseProgressResponseMsg = ns0.HttpNfcLeaseProgressResponse_Dec().pyclass + +QueryIpPoolsRequestMsg = ns0.QueryIpPools_Dec().pyclass + +QueryIpPoolsResponseMsg = ns0.QueryIpPoolsResponse_Dec().pyclass + +CreateIpPoolRequestMsg = ns0.CreateIpPool_Dec().pyclass + +CreateIpPoolResponseMsg = ns0.CreateIpPoolResponse_Dec().pyclass + +UpdateIpPoolRequestMsg = ns0.UpdateIpPool_Dec().pyclass + +UpdateIpPoolResponseMsg = ns0.UpdateIpPoolResponse_Dec().pyclass + +DestroyIpPoolRequestMsg = ns0.DestroyIpPool_Dec().pyclass + +DestroyIpPoolResponseMsg = ns0.DestroyIpPoolResponse_Dec().pyclass + +AssociateIpPoolRequestMsg = ns0.AssociateIpPool_Dec().pyclass + +AssociateIpPoolResponseMsg = ns0.AssociateIpPoolResponse_Dec().pyclass + +UpdateAssignedLicenseRequestMsg = ns0.UpdateAssignedLicense_Dec().pyclass + +UpdateAssignedLicenseResponseMsg = ns0.UpdateAssignedLicenseResponse_Dec().pyclass + +RemoveAssignedLicenseRequestMsg = ns0.RemoveAssignedLicense_Dec().pyclass + +RemoveAssignedLicenseResponseMsg = ns0.RemoveAssignedLicenseResponse_Dec().pyclass + +QueryAssignedLicensesRequestMsg = ns0.QueryAssignedLicenses_Dec().pyclass + +QueryAssignedLicensesResponseMsg = ns0.QueryAssignedLicensesResponse_Dec().pyclass + +IsFeatureAvailableRequestMsg = ns0.IsFeatureAvailable_Dec().pyclass + +IsFeatureAvailableResponseMsg = ns0.IsFeatureAvailableResponse_Dec().pyclass + +SetFeatureInUseRequestMsg = ns0.SetFeatureInUse_Dec().pyclass + +SetFeatureInUseResponseMsg = ns0.SetFeatureInUseResponse_Dec().pyclass + +ResetFeatureInUseRequestMsg = ns0.ResetFeatureInUse_Dec().pyclass + +ResetFeatureInUseResponseMsg = ns0.ResetFeatureInUseResponse_Dec().pyclass + +QuerySupportedFeaturesRequestMsg = ns0.QuerySupportedFeatures_Dec().pyclass + +QuerySupportedFeaturesResponseMsg = ns0.QuerySupportedFeaturesResponse_Dec().pyclass + +QueryLicenseSourceAvailabilityRequestMsg = ns0.QueryLicenseSourceAvailability_Dec().pyclass + +QueryLicenseSourceAvailabilityResponseMsg = ns0.QueryLicenseSourceAvailabilityResponse_Dec().pyclass + +QueryLicenseUsageRequestMsg = ns0.QueryLicenseUsage_Dec().pyclass + +QueryLicenseUsageResponseMsg = ns0.QueryLicenseUsageResponse_Dec().pyclass + +SetLicenseEditionRequestMsg = ns0.SetLicenseEdition_Dec().pyclass + +SetLicenseEditionResponseMsg = ns0.SetLicenseEditionResponse_Dec().pyclass + +CheckLicenseFeatureRequestMsg = ns0.CheckLicenseFeature_Dec().pyclass + +CheckLicenseFeatureResponseMsg = ns0.CheckLicenseFeatureResponse_Dec().pyclass + +EnableFeatureRequestMsg = ns0.EnableFeature_Dec().pyclass + +EnableFeatureResponseMsg = ns0.EnableFeatureResponse_Dec().pyclass + +DisableFeatureRequestMsg = ns0.DisableFeature_Dec().pyclass + +DisableFeatureResponseMsg = ns0.DisableFeatureResponse_Dec().pyclass + +ConfigureLicenseSourceRequestMsg = ns0.ConfigureLicenseSource_Dec().pyclass + +ConfigureLicenseSourceResponseMsg = ns0.ConfigureLicenseSourceResponse_Dec().pyclass + +UpdateLicenseRequestMsg = ns0.UpdateLicense_Dec().pyclass + +UpdateLicenseResponseMsg = ns0.UpdateLicenseResponse_Dec().pyclass + +AddLicenseRequestMsg = ns0.AddLicense_Dec().pyclass + +AddLicenseResponseMsg = ns0.AddLicenseResponse_Dec().pyclass + +RemoveLicenseRequestMsg = ns0.RemoveLicense_Dec().pyclass + +RemoveLicenseResponseMsg = ns0.RemoveLicenseResponse_Dec().pyclass + +DecodeLicenseRequestMsg = ns0.DecodeLicense_Dec().pyclass + +DecodeLicenseResponseMsg = ns0.DecodeLicenseResponse_Dec().pyclass + +UpdateLicenseLabelRequestMsg = ns0.UpdateLicenseLabel_Dec().pyclass + +UpdateLicenseLabelResponseMsg = ns0.UpdateLicenseLabelResponse_Dec().pyclass + +RemoveLicenseLabelRequestMsg = ns0.RemoveLicenseLabel_Dec().pyclass + +RemoveLicenseLabelResponseMsg = ns0.RemoveLicenseLabelResponse_Dec().pyclass + +ReloadRequestMsg = ns0.Reload_Dec().pyclass + +ReloadResponseMsg = ns0.ReloadResponse_Dec().pyclass + +RenameRequestMsg = ns0.Rename_Dec().pyclass + +RenameResponseMsg = ns0.RenameResponse_Dec().pyclass + +Rename_TaskRequestMsg = ns0.Rename_Task_Dec().pyclass + +Rename_TaskResponseMsg = ns0.Rename_TaskResponse_Dec().pyclass + +DestroyRequestMsg = ns0.Destroy_Dec().pyclass + +DestroyResponseMsg = ns0.DestroyResponse_Dec().pyclass + +Destroy_TaskRequestMsg = ns0.Destroy_Task_Dec().pyclass + +Destroy_TaskResponseMsg = ns0.Destroy_TaskResponse_Dec().pyclass + +DestroyNetworkRequestMsg = ns0.DestroyNetwork_Dec().pyclass + +DestroyNetworkResponseMsg = ns0.DestroyNetworkResponse_Dec().pyclass + +ValidateHostRequestMsg = ns0.ValidateHost_Dec().pyclass + +ValidateHostResponseMsg = ns0.ValidateHostResponse_Dec().pyclass + +ParseDescriptorRequestMsg = ns0.ParseDescriptor_Dec().pyclass + +ParseDescriptorResponseMsg = ns0.ParseDescriptorResponse_Dec().pyclass + +CreateImportSpecRequestMsg = ns0.CreateImportSpec_Dec().pyclass + +CreateImportSpecResponseMsg = ns0.CreateImportSpecResponse_Dec().pyclass + +CreateDescriptorRequestMsg = ns0.CreateDescriptor_Dec().pyclass + +CreateDescriptorResponseMsg = ns0.CreateDescriptorResponse_Dec().pyclass + +QueryPerfProviderSummaryRequestMsg = ns0.QueryPerfProviderSummary_Dec().pyclass + +QueryPerfProviderSummaryResponseMsg = ns0.QueryPerfProviderSummaryResponse_Dec().pyclass + +QueryAvailablePerfMetricRequestMsg = ns0.QueryAvailablePerfMetric_Dec().pyclass + +QueryAvailablePerfMetricResponseMsg = ns0.QueryAvailablePerfMetricResponse_Dec().pyclass + +QueryPerfCounterRequestMsg = ns0.QueryPerfCounter_Dec().pyclass + +QueryPerfCounterResponseMsg = ns0.QueryPerfCounterResponse_Dec().pyclass + +QueryPerfCounterByLevelRequestMsg = ns0.QueryPerfCounterByLevel_Dec().pyclass + +QueryPerfCounterByLevelResponseMsg = ns0.QueryPerfCounterByLevelResponse_Dec().pyclass + +QueryPerfRequestMsg = ns0.QueryPerf_Dec().pyclass + +QueryPerfResponseMsg = ns0.QueryPerfResponse_Dec().pyclass + +QueryPerfCompositeRequestMsg = ns0.QueryPerfComposite_Dec().pyclass + +QueryPerfCompositeResponseMsg = ns0.QueryPerfCompositeResponse_Dec().pyclass + +CreatePerfIntervalRequestMsg = ns0.CreatePerfInterval_Dec().pyclass + +CreatePerfIntervalResponseMsg = ns0.CreatePerfIntervalResponse_Dec().pyclass + +RemovePerfIntervalRequestMsg = ns0.RemovePerfInterval_Dec().pyclass + +RemovePerfIntervalResponseMsg = ns0.RemovePerfIntervalResponse_Dec().pyclass + +UpdatePerfIntervalRequestMsg = ns0.UpdatePerfInterval_Dec().pyclass + +UpdatePerfIntervalResponseMsg = ns0.UpdatePerfIntervalResponse_Dec().pyclass + +GetDatabaseSizeEstimateRequestMsg = ns0.GetDatabaseSizeEstimate_Dec().pyclass + +GetDatabaseSizeEstimateResponseMsg = ns0.GetDatabaseSizeEstimateResponse_Dec().pyclass + +UpdateConfigRequestMsg = ns0.UpdateConfig_Dec().pyclass + +UpdateConfigResponseMsg = ns0.UpdateConfigResponse_Dec().pyclass + +MoveIntoResourcePoolRequestMsg = ns0.MoveIntoResourcePool_Dec().pyclass + +MoveIntoResourcePoolResponseMsg = ns0.MoveIntoResourcePoolResponse_Dec().pyclass + +UpdateChildResourceConfigurationRequestMsg = ns0.UpdateChildResourceConfiguration_Dec().pyclass + +UpdateChildResourceConfigurationResponseMsg = ns0.UpdateChildResourceConfigurationResponse_Dec().pyclass + +CreateResourcePoolRequestMsg = ns0.CreateResourcePool_Dec().pyclass + +CreateResourcePoolResponseMsg = ns0.CreateResourcePoolResponse_Dec().pyclass + +DestroyChildrenRequestMsg = ns0.DestroyChildren_Dec().pyclass + +DestroyChildrenResponseMsg = ns0.DestroyChildrenResponse_Dec().pyclass + +CreateVAppRequestMsg = ns0.CreateVApp_Dec().pyclass + +CreateVAppResponseMsg = ns0.CreateVAppResponse_Dec().pyclass + +CreateChildVMRequestMsg = ns0.CreateChildVM_Dec().pyclass + +CreateChildVMResponseMsg = ns0.CreateChildVMResponse_Dec().pyclass + +CreateChildVM_TaskRequestMsg = ns0.CreateChildVM_Task_Dec().pyclass + +CreateChildVM_TaskResponseMsg = ns0.CreateChildVM_TaskResponse_Dec().pyclass + +RegisterChildVMRequestMsg = ns0.RegisterChildVM_Dec().pyclass + +RegisterChildVMResponseMsg = ns0.RegisterChildVMResponse_Dec().pyclass + +RegisterChildVM_TaskRequestMsg = ns0.RegisterChildVM_Task_Dec().pyclass + +RegisterChildVM_TaskResponseMsg = ns0.RegisterChildVM_TaskResponse_Dec().pyclass + +ImportVAppRequestMsg = ns0.ImportVApp_Dec().pyclass + +ImportVAppResponseMsg = ns0.ImportVAppResponse_Dec().pyclass + +FindByUuidRequestMsg = ns0.FindByUuid_Dec().pyclass + +FindByUuidResponseMsg = ns0.FindByUuidResponse_Dec().pyclass + +FindByDatastorePathRequestMsg = ns0.FindByDatastorePath_Dec().pyclass + +FindByDatastorePathResponseMsg = ns0.FindByDatastorePathResponse_Dec().pyclass + +FindByDnsNameRequestMsg = ns0.FindByDnsName_Dec().pyclass + +FindByDnsNameResponseMsg = ns0.FindByDnsNameResponse_Dec().pyclass + +FindByIpRequestMsg = ns0.FindByIp_Dec().pyclass + +FindByIpResponseMsg = ns0.FindByIpResponse_Dec().pyclass + +FindByInventoryPathRequestMsg = ns0.FindByInventoryPath_Dec().pyclass + +FindByInventoryPathResponseMsg = ns0.FindByInventoryPathResponse_Dec().pyclass + +FindChildRequestMsg = ns0.FindChild_Dec().pyclass + +FindChildResponseMsg = ns0.FindChildResponse_Dec().pyclass + +FindAllByUuidRequestMsg = ns0.FindAllByUuid_Dec().pyclass + +FindAllByUuidResponseMsg = ns0.FindAllByUuidResponse_Dec().pyclass + +FindAllByDnsNameRequestMsg = ns0.FindAllByDnsName_Dec().pyclass + +FindAllByDnsNameResponseMsg = ns0.FindAllByDnsNameResponse_Dec().pyclass + +FindAllByIpRequestMsg = ns0.FindAllByIp_Dec().pyclass + +FindAllByIpResponseMsg = ns0.FindAllByIpResponse_Dec().pyclass + +CurrentTimeRequestMsg = ns0.CurrentTime_Dec().pyclass + +CurrentTimeResponseMsg = ns0.CurrentTimeResponse_Dec().pyclass + +RetrieveServiceContentRequestMsg = ns0.RetrieveServiceContent_Dec().pyclass + +RetrieveServiceContentResponseMsg = ns0.RetrieveServiceContentResponse_Dec().pyclass + +ValidateMigrationRequestMsg = ns0.ValidateMigration_Dec().pyclass + +ValidateMigrationResponseMsg = ns0.ValidateMigrationResponse_Dec().pyclass + +QueryVMotionCompatibilityRequestMsg = ns0.QueryVMotionCompatibility_Dec().pyclass + +QueryVMotionCompatibilityResponseMsg = ns0.QueryVMotionCompatibilityResponse_Dec().pyclass + +RetrieveProductComponentsRequestMsg = ns0.RetrieveProductComponents_Dec().pyclass + +RetrieveProductComponentsResponseMsg = ns0.RetrieveProductComponentsResponse_Dec().pyclass + +UpdateServiceMessageRequestMsg = ns0.UpdateServiceMessage_Dec().pyclass + +UpdateServiceMessageResponseMsg = ns0.UpdateServiceMessageResponse_Dec().pyclass + +LoginRequestMsg = ns0.Login_Dec().pyclass + +LoginResponseMsg = ns0.LoginResponse_Dec().pyclass + +LoginBySSPIRequestMsg = ns0.LoginBySSPI_Dec().pyclass + +LoginBySSPIResponseMsg = ns0.LoginBySSPIResponse_Dec().pyclass + +LogoutRequestMsg = ns0.Logout_Dec().pyclass + +LogoutResponseMsg = ns0.LogoutResponse_Dec().pyclass + +AcquireLocalTicketRequestMsg = ns0.AcquireLocalTicket_Dec().pyclass + +AcquireLocalTicketResponseMsg = ns0.AcquireLocalTicketResponse_Dec().pyclass + +TerminateSessionRequestMsg = ns0.TerminateSession_Dec().pyclass + +TerminateSessionResponseMsg = ns0.TerminateSessionResponse_Dec().pyclass + +SetLocaleRequestMsg = ns0.SetLocale_Dec().pyclass + +SetLocaleResponseMsg = ns0.SetLocaleResponse_Dec().pyclass + +LoginExtensionBySubjectNameRequestMsg = ns0.LoginExtensionBySubjectName_Dec().pyclass + +LoginExtensionBySubjectNameResponseMsg = ns0.LoginExtensionBySubjectNameResponse_Dec().pyclass + +ImpersonateUserRequestMsg = ns0.ImpersonateUser_Dec().pyclass + +ImpersonateUserResponseMsg = ns0.ImpersonateUserResponse_Dec().pyclass + +SessionIsActiveRequestMsg = ns0.SessionIsActive_Dec().pyclass + +SessionIsActiveResponseMsg = ns0.SessionIsActiveResponse_Dec().pyclass + +AcquireCloneTicketRequestMsg = ns0.AcquireCloneTicket_Dec().pyclass + +AcquireCloneTicketResponseMsg = ns0.AcquireCloneTicketResponse_Dec().pyclass + +CloneSessionRequestMsg = ns0.CloneSession_Dec().pyclass + +CloneSessionResponseMsg = ns0.CloneSessionResponse_Dec().pyclass + +CancelTaskRequestMsg = ns0.CancelTask_Dec().pyclass + +CancelTaskResponseMsg = ns0.CancelTaskResponse_Dec().pyclass + +UpdateProgressRequestMsg = ns0.UpdateProgress_Dec().pyclass + +UpdateProgressResponseMsg = ns0.UpdateProgressResponse_Dec().pyclass + +SetTaskStateRequestMsg = ns0.SetTaskState_Dec().pyclass + +SetTaskStateResponseMsg = ns0.SetTaskStateResponse_Dec().pyclass + +SetTaskDescriptionRequestMsg = ns0.SetTaskDescription_Dec().pyclass + +SetTaskDescriptionResponseMsg = ns0.SetTaskDescriptionResponse_Dec().pyclass + +ReadNextTasksRequestMsg = ns0.ReadNextTasks_Dec().pyclass + +ReadNextTasksResponseMsg = ns0.ReadNextTasksResponse_Dec().pyclass + +ReadPreviousTasksRequestMsg = ns0.ReadPreviousTasks_Dec().pyclass + +ReadPreviousTasksResponseMsg = ns0.ReadPreviousTasksResponse_Dec().pyclass + +CreateCollectorForTasksRequestMsg = ns0.CreateCollectorForTasks_Dec().pyclass + +CreateCollectorForTasksResponseMsg = ns0.CreateCollectorForTasksResponse_Dec().pyclass + +CreateTaskRequestMsg = ns0.CreateTask_Dec().pyclass + +CreateTaskResponseMsg = ns0.CreateTaskResponse_Dec().pyclass + +RetrieveUserGroupsRequestMsg = ns0.RetrieveUserGroups_Dec().pyclass + +RetrieveUserGroupsResponseMsg = ns0.RetrieveUserGroupsResponse_Dec().pyclass + +UpdateVAppConfigRequestMsg = ns0.UpdateVAppConfig_Dec().pyclass + +UpdateVAppConfigResponseMsg = ns0.UpdateVAppConfigResponse_Dec().pyclass + +CloneVAppRequestMsg = ns0.CloneVApp_Dec().pyclass + +CloneVAppResponseMsg = ns0.CloneVAppResponse_Dec().pyclass + +CloneVApp_TaskRequestMsg = ns0.CloneVApp_Task_Dec().pyclass + +CloneVApp_TaskResponseMsg = ns0.CloneVApp_TaskResponse_Dec().pyclass + +ExportVAppRequestMsg = ns0.ExportVApp_Dec().pyclass + +ExportVAppResponseMsg = ns0.ExportVAppResponse_Dec().pyclass + +PowerOnVAppRequestMsg = ns0.PowerOnVApp_Dec().pyclass + +PowerOnVAppResponseMsg = ns0.PowerOnVAppResponse_Dec().pyclass + +PowerOnVApp_TaskRequestMsg = ns0.PowerOnVApp_Task_Dec().pyclass + +PowerOnVApp_TaskResponseMsg = ns0.PowerOnVApp_TaskResponse_Dec().pyclass + +PowerOffVAppRequestMsg = ns0.PowerOffVApp_Dec().pyclass + +PowerOffVAppResponseMsg = ns0.PowerOffVAppResponse_Dec().pyclass + +PowerOffVApp_TaskRequestMsg = ns0.PowerOffVApp_Task_Dec().pyclass + +PowerOffVApp_TaskResponseMsg = ns0.PowerOffVApp_TaskResponse_Dec().pyclass + +unregisterVAppRequestMsg = ns0.unregisterVApp_Dec().pyclass + +unregisterVAppResponseMsg = ns0.unregisterVAppResponse_Dec().pyclass + +unregisterVApp_TaskRequestMsg = ns0.unregisterVApp_Task_Dec().pyclass + +unregisterVApp_TaskResponseMsg = ns0.unregisterVApp_TaskResponse_Dec().pyclass + +CreateVirtualDiskRequestMsg = ns0.CreateVirtualDisk_Dec().pyclass + +CreateVirtualDiskResponseMsg = ns0.CreateVirtualDiskResponse_Dec().pyclass + +CreateVirtualDisk_TaskRequestMsg = ns0.CreateVirtualDisk_Task_Dec().pyclass + +CreateVirtualDisk_TaskResponseMsg = ns0.CreateVirtualDisk_TaskResponse_Dec().pyclass + +DeleteVirtualDiskRequestMsg = ns0.DeleteVirtualDisk_Dec().pyclass + +DeleteVirtualDiskResponseMsg = ns0.DeleteVirtualDiskResponse_Dec().pyclass + +DeleteVirtualDisk_TaskRequestMsg = ns0.DeleteVirtualDisk_Task_Dec().pyclass + +DeleteVirtualDisk_TaskResponseMsg = ns0.DeleteVirtualDisk_TaskResponse_Dec().pyclass + +MoveVirtualDiskRequestMsg = ns0.MoveVirtualDisk_Dec().pyclass + +MoveVirtualDiskResponseMsg = ns0.MoveVirtualDiskResponse_Dec().pyclass + +MoveVirtualDisk_TaskRequestMsg = ns0.MoveVirtualDisk_Task_Dec().pyclass + +MoveVirtualDisk_TaskResponseMsg = ns0.MoveVirtualDisk_TaskResponse_Dec().pyclass + +CopyVirtualDiskRequestMsg = ns0.CopyVirtualDisk_Dec().pyclass + +CopyVirtualDiskResponseMsg = ns0.CopyVirtualDiskResponse_Dec().pyclass + +CopyVirtualDisk_TaskRequestMsg = ns0.CopyVirtualDisk_Task_Dec().pyclass + +CopyVirtualDisk_TaskResponseMsg = ns0.CopyVirtualDisk_TaskResponse_Dec().pyclass + +ExtendVirtualDiskRequestMsg = ns0.ExtendVirtualDisk_Dec().pyclass + +ExtendVirtualDiskResponseMsg = ns0.ExtendVirtualDiskResponse_Dec().pyclass + +ExtendVirtualDisk_TaskRequestMsg = ns0.ExtendVirtualDisk_Task_Dec().pyclass + +ExtendVirtualDisk_TaskResponseMsg = ns0.ExtendVirtualDisk_TaskResponse_Dec().pyclass + +QueryVirtualDiskFragmentationRequestMsg = ns0.QueryVirtualDiskFragmentation_Dec().pyclass + +QueryVirtualDiskFragmentationResponseMsg = ns0.QueryVirtualDiskFragmentationResponse_Dec().pyclass + +DefragmentVirtualDiskRequestMsg = ns0.DefragmentVirtualDisk_Dec().pyclass + +DefragmentVirtualDiskResponseMsg = ns0.DefragmentVirtualDiskResponse_Dec().pyclass + +DefragmentVirtualDisk_TaskRequestMsg = ns0.DefragmentVirtualDisk_Task_Dec().pyclass + +DefragmentVirtualDisk_TaskResponseMsg = ns0.DefragmentVirtualDisk_TaskResponse_Dec().pyclass + +ShrinkVirtualDiskRequestMsg = ns0.ShrinkVirtualDisk_Dec().pyclass + +ShrinkVirtualDiskResponseMsg = ns0.ShrinkVirtualDiskResponse_Dec().pyclass + +ShrinkVirtualDisk_TaskRequestMsg = ns0.ShrinkVirtualDisk_Task_Dec().pyclass + +ShrinkVirtualDisk_TaskResponseMsg = ns0.ShrinkVirtualDisk_TaskResponse_Dec().pyclass + +InflateVirtualDiskRequestMsg = ns0.InflateVirtualDisk_Dec().pyclass + +InflateVirtualDiskResponseMsg = ns0.InflateVirtualDiskResponse_Dec().pyclass + +InflateVirtualDisk_TaskRequestMsg = ns0.InflateVirtualDisk_Task_Dec().pyclass + +InflateVirtualDisk_TaskResponseMsg = ns0.InflateVirtualDisk_TaskResponse_Dec().pyclass + +EagerZeroVirtualDiskRequestMsg = ns0.EagerZeroVirtualDisk_Dec().pyclass + +EagerZeroVirtualDiskResponseMsg = ns0.EagerZeroVirtualDiskResponse_Dec().pyclass + +EagerZeroVirtualDisk_TaskRequestMsg = ns0.EagerZeroVirtualDisk_Task_Dec().pyclass + +EagerZeroVirtualDisk_TaskResponseMsg = ns0.EagerZeroVirtualDisk_TaskResponse_Dec().pyclass + +ZeroFillVirtualDiskRequestMsg = ns0.ZeroFillVirtualDisk_Dec().pyclass + +ZeroFillVirtualDiskResponseMsg = ns0.ZeroFillVirtualDiskResponse_Dec().pyclass + +ZeroFillVirtualDisk_TaskRequestMsg = ns0.ZeroFillVirtualDisk_Task_Dec().pyclass + +ZeroFillVirtualDisk_TaskResponseMsg = ns0.ZeroFillVirtualDisk_TaskResponse_Dec().pyclass + +SetVirtualDiskUuidRequestMsg = ns0.SetVirtualDiskUuid_Dec().pyclass + +SetVirtualDiskUuidResponseMsg = ns0.SetVirtualDiskUuidResponse_Dec().pyclass + +QueryVirtualDiskUuidRequestMsg = ns0.QueryVirtualDiskUuid_Dec().pyclass + +QueryVirtualDiskUuidResponseMsg = ns0.QueryVirtualDiskUuidResponse_Dec().pyclass + +QueryVirtualDiskGeometryRequestMsg = ns0.QueryVirtualDiskGeometry_Dec().pyclass + +QueryVirtualDiskGeometryResponseMsg = ns0.QueryVirtualDiskGeometryResponse_Dec().pyclass + +RefreshStorageInfoRequestMsg = ns0.RefreshStorageInfo_Dec().pyclass + +RefreshStorageInfoResponseMsg = ns0.RefreshStorageInfoResponse_Dec().pyclass + +CreateSnapshotRequestMsg = ns0.CreateSnapshot_Dec().pyclass + +CreateSnapshotResponseMsg = ns0.CreateSnapshotResponse_Dec().pyclass + +CreateSnapshot_TaskRequestMsg = ns0.CreateSnapshot_Task_Dec().pyclass + +CreateSnapshot_TaskResponseMsg = ns0.CreateSnapshot_TaskResponse_Dec().pyclass + +RevertToCurrentSnapshotRequestMsg = ns0.RevertToCurrentSnapshot_Dec().pyclass + +RevertToCurrentSnapshotResponseMsg = ns0.RevertToCurrentSnapshotResponse_Dec().pyclass + +RevertToCurrentSnapshot_TaskRequestMsg = ns0.RevertToCurrentSnapshot_Task_Dec().pyclass + +RevertToCurrentSnapshot_TaskResponseMsg = ns0.RevertToCurrentSnapshot_TaskResponse_Dec().pyclass + +RemoveAllSnapshotsRequestMsg = ns0.RemoveAllSnapshots_Dec().pyclass + +RemoveAllSnapshotsResponseMsg = ns0.RemoveAllSnapshotsResponse_Dec().pyclass + +RemoveAllSnapshots_TaskRequestMsg = ns0.RemoveAllSnapshots_Task_Dec().pyclass + +RemoveAllSnapshots_TaskResponseMsg = ns0.RemoveAllSnapshots_TaskResponse_Dec().pyclass + +ReconfigVMRequestMsg = ns0.ReconfigVM_Dec().pyclass + +ReconfigVMResponseMsg = ns0.ReconfigVMResponse_Dec().pyclass + +ReconfigVM_TaskRequestMsg = ns0.ReconfigVM_Task_Dec().pyclass + +ReconfigVM_TaskResponseMsg = ns0.ReconfigVM_TaskResponse_Dec().pyclass + +UpgradeVMRequestMsg = ns0.UpgradeVM_Dec().pyclass + +UpgradeVMResponseMsg = ns0.UpgradeVMResponse_Dec().pyclass + +UpgradeVM_TaskRequestMsg = ns0.UpgradeVM_Task_Dec().pyclass + +UpgradeVM_TaskResponseMsg = ns0.UpgradeVM_TaskResponse_Dec().pyclass + +ExtractOvfEnvironmentRequestMsg = ns0.ExtractOvfEnvironment_Dec().pyclass + +ExtractOvfEnvironmentResponseMsg = ns0.ExtractOvfEnvironmentResponse_Dec().pyclass + +PowerOnVMRequestMsg = ns0.PowerOnVM_Dec().pyclass + +PowerOnVMResponseMsg = ns0.PowerOnVMResponse_Dec().pyclass + +PowerOnVM_TaskRequestMsg = ns0.PowerOnVM_Task_Dec().pyclass + +PowerOnVM_TaskResponseMsg = ns0.PowerOnVM_TaskResponse_Dec().pyclass + +PowerOffVMRequestMsg = ns0.PowerOffVM_Dec().pyclass + +PowerOffVMResponseMsg = ns0.PowerOffVMResponse_Dec().pyclass + +PowerOffVM_TaskRequestMsg = ns0.PowerOffVM_Task_Dec().pyclass + +PowerOffVM_TaskResponseMsg = ns0.PowerOffVM_TaskResponse_Dec().pyclass + +SuspendVMRequestMsg = ns0.SuspendVM_Dec().pyclass + +SuspendVMResponseMsg = ns0.SuspendVMResponse_Dec().pyclass + +SuspendVM_TaskRequestMsg = ns0.SuspendVM_Task_Dec().pyclass + +SuspendVM_TaskResponseMsg = ns0.SuspendVM_TaskResponse_Dec().pyclass + +ResetVMRequestMsg = ns0.ResetVM_Dec().pyclass + +ResetVMResponseMsg = ns0.ResetVMResponse_Dec().pyclass + +ResetVM_TaskRequestMsg = ns0.ResetVM_Task_Dec().pyclass + +ResetVM_TaskResponseMsg = ns0.ResetVM_TaskResponse_Dec().pyclass + +ShutdownGuestRequestMsg = ns0.ShutdownGuest_Dec().pyclass + +ShutdownGuestResponseMsg = ns0.ShutdownGuestResponse_Dec().pyclass + +RebootGuestRequestMsg = ns0.RebootGuest_Dec().pyclass + +RebootGuestResponseMsg = ns0.RebootGuestResponse_Dec().pyclass + +StandbyGuestRequestMsg = ns0.StandbyGuest_Dec().pyclass + +StandbyGuestResponseMsg = ns0.StandbyGuestResponse_Dec().pyclass + +AnswerVMRequestMsg = ns0.AnswerVM_Dec().pyclass + +AnswerVMResponseMsg = ns0.AnswerVMResponse_Dec().pyclass + +CustomizeVMRequestMsg = ns0.CustomizeVM_Dec().pyclass + +CustomizeVMResponseMsg = ns0.CustomizeVMResponse_Dec().pyclass + +CustomizeVM_TaskRequestMsg = ns0.CustomizeVM_Task_Dec().pyclass + +CustomizeVM_TaskResponseMsg = ns0.CustomizeVM_TaskResponse_Dec().pyclass + +CheckCustomizationSpecRequestMsg = ns0.CheckCustomizationSpec_Dec().pyclass + +CheckCustomizationSpecResponseMsg = ns0.CheckCustomizationSpecResponse_Dec().pyclass + +MigrateVMRequestMsg = ns0.MigrateVM_Dec().pyclass + +MigrateVMResponseMsg = ns0.MigrateVMResponse_Dec().pyclass + +MigrateVM_TaskRequestMsg = ns0.MigrateVM_Task_Dec().pyclass + +MigrateVM_TaskResponseMsg = ns0.MigrateVM_TaskResponse_Dec().pyclass + +RelocateVMRequestMsg = ns0.RelocateVM_Dec().pyclass + +RelocateVMResponseMsg = ns0.RelocateVMResponse_Dec().pyclass + +RelocateVM_TaskRequestMsg = ns0.RelocateVM_Task_Dec().pyclass + +RelocateVM_TaskResponseMsg = ns0.RelocateVM_TaskResponse_Dec().pyclass + +CloneVMRequestMsg = ns0.CloneVM_Dec().pyclass + +CloneVMResponseMsg = ns0.CloneVMResponse_Dec().pyclass + +CloneVM_TaskRequestMsg = ns0.CloneVM_Task_Dec().pyclass + +CloneVM_TaskResponseMsg = ns0.CloneVM_TaskResponse_Dec().pyclass + +ExportVmRequestMsg = ns0.ExportVm_Dec().pyclass + +ExportVmResponseMsg = ns0.ExportVmResponse_Dec().pyclass + +MarkAsTemplateRequestMsg = ns0.MarkAsTemplate_Dec().pyclass + +MarkAsTemplateResponseMsg = ns0.MarkAsTemplateResponse_Dec().pyclass + +MarkAsVirtualMachineRequestMsg = ns0.MarkAsVirtualMachine_Dec().pyclass + +MarkAsVirtualMachineResponseMsg = ns0.MarkAsVirtualMachineResponse_Dec().pyclass + +UnregisterVMRequestMsg = ns0.UnregisterVM_Dec().pyclass + +UnregisterVMResponseMsg = ns0.UnregisterVMResponse_Dec().pyclass + +ResetGuestInformationRequestMsg = ns0.ResetGuestInformation_Dec().pyclass + +ResetGuestInformationResponseMsg = ns0.ResetGuestInformationResponse_Dec().pyclass + +MountToolsInstallerRequestMsg = ns0.MountToolsInstaller_Dec().pyclass + +MountToolsInstallerResponseMsg = ns0.MountToolsInstallerResponse_Dec().pyclass + +UnmountToolsInstallerRequestMsg = ns0.UnmountToolsInstaller_Dec().pyclass + +UnmountToolsInstallerResponseMsg = ns0.UnmountToolsInstallerResponse_Dec().pyclass + +UpgradeToolsRequestMsg = ns0.UpgradeTools_Dec().pyclass + +UpgradeToolsResponseMsg = ns0.UpgradeToolsResponse_Dec().pyclass + +UpgradeTools_TaskRequestMsg = ns0.UpgradeTools_Task_Dec().pyclass + +UpgradeTools_TaskResponseMsg = ns0.UpgradeTools_TaskResponse_Dec().pyclass + +AcquireMksTicketRequestMsg = ns0.AcquireMksTicket_Dec().pyclass + +AcquireMksTicketResponseMsg = ns0.AcquireMksTicketResponse_Dec().pyclass + +SetScreenResolutionRequestMsg = ns0.SetScreenResolution_Dec().pyclass + +SetScreenResolutionResponseMsg = ns0.SetScreenResolutionResponse_Dec().pyclass + +DefragmentAllDisksRequestMsg = ns0.DefragmentAllDisks_Dec().pyclass + +DefragmentAllDisksResponseMsg = ns0.DefragmentAllDisksResponse_Dec().pyclass + +CreateSecondaryVMRequestMsg = ns0.CreateSecondaryVM_Dec().pyclass + +CreateSecondaryVMResponseMsg = ns0.CreateSecondaryVMResponse_Dec().pyclass + +CreateSecondaryVM_TaskRequestMsg = ns0.CreateSecondaryVM_Task_Dec().pyclass + +CreateSecondaryVM_TaskResponseMsg = ns0.CreateSecondaryVM_TaskResponse_Dec().pyclass + +TurnOffFaultToleranceForVMRequestMsg = ns0.TurnOffFaultToleranceForVM_Dec().pyclass + +TurnOffFaultToleranceForVMResponseMsg = ns0.TurnOffFaultToleranceForVMResponse_Dec().pyclass + +TurnOffFaultToleranceForVM_TaskRequestMsg = ns0.TurnOffFaultToleranceForVM_Task_Dec().pyclass + +TurnOffFaultToleranceForVM_TaskResponseMsg = ns0.TurnOffFaultToleranceForVM_TaskResponse_Dec().pyclass + +MakePrimaryVMRequestMsg = ns0.MakePrimaryVM_Dec().pyclass + +MakePrimaryVMResponseMsg = ns0.MakePrimaryVMResponse_Dec().pyclass + +MakePrimaryVM_TaskRequestMsg = ns0.MakePrimaryVM_Task_Dec().pyclass + +MakePrimaryVM_TaskResponseMsg = ns0.MakePrimaryVM_TaskResponse_Dec().pyclass + +TerminateFaultTolerantVMRequestMsg = ns0.TerminateFaultTolerantVM_Dec().pyclass + +TerminateFaultTolerantVMResponseMsg = ns0.TerminateFaultTolerantVMResponse_Dec().pyclass + +TerminateFaultTolerantVM_TaskRequestMsg = ns0.TerminateFaultTolerantVM_Task_Dec().pyclass + +TerminateFaultTolerantVM_TaskResponseMsg = ns0.TerminateFaultTolerantVM_TaskResponse_Dec().pyclass + +DisableSecondaryVMRequestMsg = ns0.DisableSecondaryVM_Dec().pyclass + +DisableSecondaryVMResponseMsg = ns0.DisableSecondaryVMResponse_Dec().pyclass + +DisableSecondaryVM_TaskRequestMsg = ns0.DisableSecondaryVM_Task_Dec().pyclass + +DisableSecondaryVM_TaskResponseMsg = ns0.DisableSecondaryVM_TaskResponse_Dec().pyclass + +EnableSecondaryVMRequestMsg = ns0.EnableSecondaryVM_Dec().pyclass + +EnableSecondaryVMResponseMsg = ns0.EnableSecondaryVMResponse_Dec().pyclass + +EnableSecondaryVM_TaskRequestMsg = ns0.EnableSecondaryVM_Task_Dec().pyclass + +EnableSecondaryVM_TaskResponseMsg = ns0.EnableSecondaryVM_TaskResponse_Dec().pyclass + +SetDisplayTopologyRequestMsg = ns0.SetDisplayTopology_Dec().pyclass + +SetDisplayTopologyResponseMsg = ns0.SetDisplayTopologyResponse_Dec().pyclass + +StartRecordingRequestMsg = ns0.StartRecording_Dec().pyclass + +StartRecordingResponseMsg = ns0.StartRecordingResponse_Dec().pyclass + +StartRecording_TaskRequestMsg = ns0.StartRecording_Task_Dec().pyclass + +StartRecording_TaskResponseMsg = ns0.StartRecording_TaskResponse_Dec().pyclass + +StopRecordingRequestMsg = ns0.StopRecording_Dec().pyclass + +StopRecordingResponseMsg = ns0.StopRecordingResponse_Dec().pyclass + +StopRecording_TaskRequestMsg = ns0.StopRecording_Task_Dec().pyclass + +StopRecording_TaskResponseMsg = ns0.StopRecording_TaskResponse_Dec().pyclass + +StartReplayingRequestMsg = ns0.StartReplaying_Dec().pyclass + +StartReplayingResponseMsg = ns0.StartReplayingResponse_Dec().pyclass + +StartReplaying_TaskRequestMsg = ns0.StartReplaying_Task_Dec().pyclass + +StartReplaying_TaskResponseMsg = ns0.StartReplaying_TaskResponse_Dec().pyclass + +StopReplayingRequestMsg = ns0.StopReplaying_Dec().pyclass + +StopReplayingResponseMsg = ns0.StopReplayingResponse_Dec().pyclass + +StopReplaying_TaskRequestMsg = ns0.StopReplaying_Task_Dec().pyclass + +StopReplaying_TaskResponseMsg = ns0.StopReplaying_TaskResponse_Dec().pyclass + +PromoteDisksRequestMsg = ns0.PromoteDisks_Dec().pyclass + +PromoteDisksResponseMsg = ns0.PromoteDisksResponse_Dec().pyclass + +PromoteDisks_TaskRequestMsg = ns0.PromoteDisks_Task_Dec().pyclass + +PromoteDisks_TaskResponseMsg = ns0.PromoteDisks_TaskResponse_Dec().pyclass + +CreateScreenshotRequestMsg = ns0.CreateScreenshot_Dec().pyclass + +CreateScreenshotResponseMsg = ns0.CreateScreenshotResponse_Dec().pyclass + +CreateScreenshot_TaskRequestMsg = ns0.CreateScreenshot_Task_Dec().pyclass + +CreateScreenshot_TaskResponseMsg = ns0.CreateScreenshot_TaskResponse_Dec().pyclass + +QueryChangedDiskAreasRequestMsg = ns0.QueryChangedDiskAreas_Dec().pyclass + +QueryChangedDiskAreasResponseMsg = ns0.QueryChangedDiskAreasResponse_Dec().pyclass + +QueryUnownedFilesRequestMsg = ns0.QueryUnownedFiles_Dec().pyclass + +QueryUnownedFilesResponseMsg = ns0.QueryUnownedFilesResponse_Dec().pyclass + +RemoveAlarmRequestMsg = ns0.RemoveAlarm_Dec().pyclass + +RemoveAlarmResponseMsg = ns0.RemoveAlarmResponse_Dec().pyclass + +ReconfigureAlarmRequestMsg = ns0.ReconfigureAlarm_Dec().pyclass + +ReconfigureAlarmResponseMsg = ns0.ReconfigureAlarmResponse_Dec().pyclass + +CreateAlarmRequestMsg = ns0.CreateAlarm_Dec().pyclass + +CreateAlarmResponseMsg = ns0.CreateAlarmResponse_Dec().pyclass + +GetAlarmRequestMsg = ns0.GetAlarm_Dec().pyclass + +GetAlarmResponseMsg = ns0.GetAlarmResponse_Dec().pyclass + +GetAlarmActionsEnabledRequestMsg = ns0.GetAlarmActionsEnabled_Dec().pyclass + +GetAlarmActionsEnabledResponseMsg = ns0.GetAlarmActionsEnabledResponse_Dec().pyclass + +SetAlarmActionsEnabledRequestMsg = ns0.SetAlarmActionsEnabled_Dec().pyclass + +SetAlarmActionsEnabledResponseMsg = ns0.SetAlarmActionsEnabledResponse_Dec().pyclass + +GetAlarmStateRequestMsg = ns0.GetAlarmState_Dec().pyclass + +GetAlarmStateResponseMsg = ns0.GetAlarmStateResponse_Dec().pyclass + +AcknowledgeAlarmRequestMsg = ns0.AcknowledgeAlarm_Dec().pyclass + +AcknowledgeAlarmResponseMsg = ns0.AcknowledgeAlarmResponse_Dec().pyclass + +DVPortgroupReconfigureRequestMsg = ns0.DVPortgroupReconfigure_Dec().pyclass + +DVPortgroupReconfigureResponseMsg = ns0.DVPortgroupReconfigureResponse_Dec().pyclass + +DVSManagerQueryAvailableSwitchSpecRequestMsg = ns0.DVSManagerQueryAvailableSwitchSpec_Dec().pyclass + +DVSManagerQueryAvailableSwitchSpecResponseMsg = ns0.DVSManagerQueryAvailableSwitchSpecResponse_Dec().pyclass + +DVSManagerQueryCompatibleHostForNewDvsRequestMsg = ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec().pyclass + +DVSManagerQueryCompatibleHostForNewDvsResponseMsg = ns0.DVSManagerQueryCompatibleHostForNewDvsResponse_Dec().pyclass + +DVSManagerQueryCompatibleHostForExistingDvsRequestMsg = ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec().pyclass + +DVSManagerQueryCompatibleHostForExistingDvsResponseMsg = ns0.DVSManagerQueryCompatibleHostForExistingDvsResponse_Dec().pyclass + +DVSManagerQueryCompatibleHostSpecRequestMsg = ns0.DVSManagerQueryCompatibleHostSpec_Dec().pyclass + +DVSManagerQueryCompatibleHostSpecResponseMsg = ns0.DVSManagerQueryCompatibleHostSpecResponse_Dec().pyclass + +DVSManagerQuerySwitchByUuidRequestMsg = ns0.DVSManagerQuerySwitchByUuid_Dec().pyclass + +DVSManagerQuerySwitchByUuidResponseMsg = ns0.DVSManagerQuerySwitchByUuidResponse_Dec().pyclass + +DVSManagerQueryDvsConfigTargetRequestMsg = ns0.DVSManagerQueryDvsConfigTarget_Dec().pyclass + +DVSManagerQueryDvsConfigTargetResponseMsg = ns0.DVSManagerQueryDvsConfigTargetResponse_Dec().pyclass + +ReadNextEventsRequestMsg = ns0.ReadNextEvents_Dec().pyclass + +ReadNextEventsResponseMsg = ns0.ReadNextEventsResponse_Dec().pyclass + +ReadPreviousEventsRequestMsg = ns0.ReadPreviousEvents_Dec().pyclass + +ReadPreviousEventsResponseMsg = ns0.ReadPreviousEventsResponse_Dec().pyclass + +RetrieveArgumentDescriptionRequestMsg = ns0.RetrieveArgumentDescription_Dec().pyclass + +RetrieveArgumentDescriptionResponseMsg = ns0.RetrieveArgumentDescriptionResponse_Dec().pyclass + +CreateCollectorForEventsRequestMsg = ns0.CreateCollectorForEvents_Dec().pyclass + +CreateCollectorForEventsResponseMsg = ns0.CreateCollectorForEventsResponse_Dec().pyclass + +LogUserEventRequestMsg = ns0.LogUserEvent_Dec().pyclass + +LogUserEventResponseMsg = ns0.LogUserEventResponse_Dec().pyclass + +QueryEventsRequestMsg = ns0.QueryEvents_Dec().pyclass + +QueryEventsResponseMsg = ns0.QueryEventsResponse_Dec().pyclass + +PostEventRequestMsg = ns0.PostEvent_Dec().pyclass + +PostEventResponseMsg = ns0.PostEventResponse_Dec().pyclass + +ReconfigureAutostartRequestMsg = ns0.ReconfigureAutostart_Dec().pyclass + +ReconfigureAutostartResponseMsg = ns0.ReconfigureAutostartResponse_Dec().pyclass + +AutoStartPowerOnRequestMsg = ns0.AutoStartPowerOn_Dec().pyclass + +AutoStartPowerOnResponseMsg = ns0.AutoStartPowerOnResponse_Dec().pyclass + +AutoStartPowerOffRequestMsg = ns0.AutoStartPowerOff_Dec().pyclass + +AutoStartPowerOffResponseMsg = ns0.AutoStartPowerOffResponse_Dec().pyclass + +QueryBootDevicesRequestMsg = ns0.QueryBootDevices_Dec().pyclass + +QueryBootDevicesResponseMsg = ns0.QueryBootDevicesResponse_Dec().pyclass + +UpdateBootDeviceRequestMsg = ns0.UpdateBootDevice_Dec().pyclass + +UpdateBootDeviceResponseMsg = ns0.UpdateBootDeviceResponse_Dec().pyclass + +EnableHyperThreadingRequestMsg = ns0.EnableHyperThreading_Dec().pyclass + +EnableHyperThreadingResponseMsg = ns0.EnableHyperThreadingResponse_Dec().pyclass + +DisableHyperThreadingRequestMsg = ns0.DisableHyperThreading_Dec().pyclass + +DisableHyperThreadingResponseMsg = ns0.DisableHyperThreadingResponse_Dec().pyclass + +SearchDatastoreRequestMsg = ns0.SearchDatastore_Dec().pyclass + +SearchDatastoreResponseMsg = ns0.SearchDatastoreResponse_Dec().pyclass + +SearchDatastore_TaskRequestMsg = ns0.SearchDatastore_Task_Dec().pyclass + +SearchDatastore_TaskResponseMsg = ns0.SearchDatastore_TaskResponse_Dec().pyclass + +SearchDatastoreSubFoldersRequestMsg = ns0.SearchDatastoreSubFolders_Dec().pyclass + +SearchDatastoreSubFoldersResponseMsg = ns0.SearchDatastoreSubFoldersResponse_Dec().pyclass + +SearchDatastoreSubFolders_TaskRequestMsg = ns0.SearchDatastoreSubFolders_Task_Dec().pyclass + +SearchDatastoreSubFolders_TaskResponseMsg = ns0.SearchDatastoreSubFolders_TaskResponse_Dec().pyclass + +DeleteFileRequestMsg = ns0.DeleteFile_Dec().pyclass + +DeleteFileResponseMsg = ns0.DeleteFileResponse_Dec().pyclass + +UpdateLocalSwapDatastoreRequestMsg = ns0.UpdateLocalSwapDatastore_Dec().pyclass + +UpdateLocalSwapDatastoreResponseMsg = ns0.UpdateLocalSwapDatastoreResponse_Dec().pyclass + +QueryAvailableDisksForVmfsRequestMsg = ns0.QueryAvailableDisksForVmfs_Dec().pyclass + +QueryAvailableDisksForVmfsResponseMsg = ns0.QueryAvailableDisksForVmfsResponse_Dec().pyclass + +QueryVmfsDatastoreCreateOptionsRequestMsg = ns0.QueryVmfsDatastoreCreateOptions_Dec().pyclass + +QueryVmfsDatastoreCreateOptionsResponseMsg = ns0.QueryVmfsDatastoreCreateOptionsResponse_Dec().pyclass + +CreateVmfsDatastoreRequestMsg = ns0.CreateVmfsDatastore_Dec().pyclass + +CreateVmfsDatastoreResponseMsg = ns0.CreateVmfsDatastoreResponse_Dec().pyclass + +QueryVmfsDatastoreExtendOptionsRequestMsg = ns0.QueryVmfsDatastoreExtendOptions_Dec().pyclass + +QueryVmfsDatastoreExtendOptionsResponseMsg = ns0.QueryVmfsDatastoreExtendOptionsResponse_Dec().pyclass + +QueryVmfsDatastoreExpandOptionsRequestMsg = ns0.QueryVmfsDatastoreExpandOptions_Dec().pyclass + +QueryVmfsDatastoreExpandOptionsResponseMsg = ns0.QueryVmfsDatastoreExpandOptionsResponse_Dec().pyclass + +ExtendVmfsDatastoreRequestMsg = ns0.ExtendVmfsDatastore_Dec().pyclass + +ExtendVmfsDatastoreResponseMsg = ns0.ExtendVmfsDatastoreResponse_Dec().pyclass + +ExpandVmfsDatastoreRequestMsg = ns0.ExpandVmfsDatastore_Dec().pyclass + +ExpandVmfsDatastoreResponseMsg = ns0.ExpandVmfsDatastoreResponse_Dec().pyclass + +CreateNasDatastoreRequestMsg = ns0.CreateNasDatastore_Dec().pyclass + +CreateNasDatastoreResponseMsg = ns0.CreateNasDatastoreResponse_Dec().pyclass + +CreateLocalDatastoreRequestMsg = ns0.CreateLocalDatastore_Dec().pyclass + +CreateLocalDatastoreResponseMsg = ns0.CreateLocalDatastoreResponse_Dec().pyclass + +RemoveDatastoreRequestMsg = ns0.RemoveDatastore_Dec().pyclass + +RemoveDatastoreResponseMsg = ns0.RemoveDatastoreResponse_Dec().pyclass + +ConfigureDatastorePrincipalRequestMsg = ns0.ConfigureDatastorePrincipal_Dec().pyclass + +ConfigureDatastorePrincipalResponseMsg = ns0.ConfigureDatastorePrincipalResponse_Dec().pyclass + +QueryUnresolvedVmfsVolumesRequestMsg = ns0.QueryUnresolvedVmfsVolumes_Dec().pyclass + +QueryUnresolvedVmfsVolumesResponseMsg = ns0.QueryUnresolvedVmfsVolumesResponse_Dec().pyclass + +ResignatureUnresolvedVmfsVolumeRequestMsg = ns0.ResignatureUnresolvedVmfsVolume_Dec().pyclass + +ResignatureUnresolvedVmfsVolumeResponseMsg = ns0.ResignatureUnresolvedVmfsVolumeResponse_Dec().pyclass + +ResignatureUnresolvedVmfsVolume_TaskRequestMsg = ns0.ResignatureUnresolvedVmfsVolume_Task_Dec().pyclass + +ResignatureUnresolvedVmfsVolume_TaskResponseMsg = ns0.ResignatureUnresolvedVmfsVolume_TaskResponse_Dec().pyclass + +UpdateDateTimeConfigRequestMsg = ns0.UpdateDateTimeConfig_Dec().pyclass + +UpdateDateTimeConfigResponseMsg = ns0.UpdateDateTimeConfigResponse_Dec().pyclass + +QueryAvailableTimeZonesRequestMsg = ns0.QueryAvailableTimeZones_Dec().pyclass + +QueryAvailableTimeZonesResponseMsg = ns0.QueryAvailableTimeZonesResponse_Dec().pyclass + +QueryDateTimeRequestMsg = ns0.QueryDateTime_Dec().pyclass + +QueryDateTimeResponseMsg = ns0.QueryDateTimeResponse_Dec().pyclass + +UpdateDateTimeRequestMsg = ns0.UpdateDateTime_Dec().pyclass + +UpdateDateTimeResponseMsg = ns0.UpdateDateTimeResponse_Dec().pyclass + +RefreshDateTimeSystemRequestMsg = ns0.RefreshDateTimeSystem_Dec().pyclass + +RefreshDateTimeSystemResponseMsg = ns0.RefreshDateTimeSystemResponse_Dec().pyclass + +QueryAvailablePartitionRequestMsg = ns0.QueryAvailablePartition_Dec().pyclass + +QueryAvailablePartitionResponseMsg = ns0.QueryAvailablePartitionResponse_Dec().pyclass + +SelectActivePartitionRequestMsg = ns0.SelectActivePartition_Dec().pyclass + +SelectActivePartitionResponseMsg = ns0.SelectActivePartitionResponse_Dec().pyclass + +QueryPartitionCreateOptionsRequestMsg = ns0.QueryPartitionCreateOptions_Dec().pyclass + +QueryPartitionCreateOptionsResponseMsg = ns0.QueryPartitionCreateOptionsResponse_Dec().pyclass + +QueryPartitionCreateDescRequestMsg = ns0.QueryPartitionCreateDesc_Dec().pyclass + +QueryPartitionCreateDescResponseMsg = ns0.QueryPartitionCreateDescResponse_Dec().pyclass + +CreateDiagnosticPartitionRequestMsg = ns0.CreateDiagnosticPartition_Dec().pyclass + +CreateDiagnosticPartitionResponseMsg = ns0.CreateDiagnosticPartitionResponse_Dec().pyclass + +UpdateDefaultPolicyRequestMsg = ns0.UpdateDefaultPolicy_Dec().pyclass + +UpdateDefaultPolicyResponseMsg = ns0.UpdateDefaultPolicyResponse_Dec().pyclass + +EnableRulesetRequestMsg = ns0.EnableRuleset_Dec().pyclass + +EnableRulesetResponseMsg = ns0.EnableRulesetResponse_Dec().pyclass + +DisableRulesetRequestMsg = ns0.DisableRuleset_Dec().pyclass + +DisableRulesetResponseMsg = ns0.DisableRulesetResponse_Dec().pyclass + +RefreshFirewallRequestMsg = ns0.RefreshFirewall_Dec().pyclass + +RefreshFirewallResponseMsg = ns0.RefreshFirewallResponse_Dec().pyclass + +ResetFirmwareToFactoryDefaultsRequestMsg = ns0.ResetFirmwareToFactoryDefaults_Dec().pyclass + +ResetFirmwareToFactoryDefaultsResponseMsg = ns0.ResetFirmwareToFactoryDefaultsResponse_Dec().pyclass + +BackupFirmwareConfigurationRequestMsg = ns0.BackupFirmwareConfiguration_Dec().pyclass + +BackupFirmwareConfigurationResponseMsg = ns0.BackupFirmwareConfigurationResponse_Dec().pyclass + +QueryFirmwareConfigUploadURLRequestMsg = ns0.QueryFirmwareConfigUploadURL_Dec().pyclass + +QueryFirmwareConfigUploadURLResponseMsg = ns0.QueryFirmwareConfigUploadURLResponse_Dec().pyclass + +RestoreFirmwareConfigurationRequestMsg = ns0.RestoreFirmwareConfiguration_Dec().pyclass + +RestoreFirmwareConfigurationResponseMsg = ns0.RestoreFirmwareConfigurationResponse_Dec().pyclass + +RefreshHealthStatusSystemRequestMsg = ns0.RefreshHealthStatusSystem_Dec().pyclass + +RefreshHealthStatusSystemResponseMsg = ns0.RefreshHealthStatusSystemResponse_Dec().pyclass + +ResetSystemHealthInfoRequestMsg = ns0.ResetSystemHealthInfo_Dec().pyclass + +ResetSystemHealthInfoResponseMsg = ns0.ResetSystemHealthInfoResponse_Dec().pyclass + +QueryModulesRequestMsg = ns0.QueryModules_Dec().pyclass + +QueryModulesResponseMsg = ns0.QueryModulesResponse_Dec().pyclass + +UpdateModuleOptionStringRequestMsg = ns0.UpdateModuleOptionString_Dec().pyclass + +UpdateModuleOptionStringResponseMsg = ns0.UpdateModuleOptionStringResponse_Dec().pyclass + +QueryConfiguredModuleOptionStringRequestMsg = ns0.QueryConfiguredModuleOptionString_Dec().pyclass + +QueryConfiguredModuleOptionStringResponseMsg = ns0.QueryConfiguredModuleOptionStringResponse_Dec().pyclass + +CreateUserRequestMsg = ns0.CreateUser_Dec().pyclass + +CreateUserResponseMsg = ns0.CreateUserResponse_Dec().pyclass + +UpdateUserRequestMsg = ns0.UpdateUser_Dec().pyclass + +UpdateUserResponseMsg = ns0.UpdateUserResponse_Dec().pyclass + +CreateGroupRequestMsg = ns0.CreateGroup_Dec().pyclass + +CreateGroupResponseMsg = ns0.CreateGroupResponse_Dec().pyclass + +RemoveUserRequestMsg = ns0.RemoveUser_Dec().pyclass + +RemoveUserResponseMsg = ns0.RemoveUserResponse_Dec().pyclass + +RemoveGroupRequestMsg = ns0.RemoveGroup_Dec().pyclass + +RemoveGroupResponseMsg = ns0.RemoveGroupResponse_Dec().pyclass + +AssignUserToGroupRequestMsg = ns0.AssignUserToGroup_Dec().pyclass + +AssignUserToGroupResponseMsg = ns0.AssignUserToGroupResponse_Dec().pyclass + +UnassignUserFromGroupRequestMsg = ns0.UnassignUserFromGroup_Dec().pyclass + +UnassignUserFromGroupResponseMsg = ns0.UnassignUserFromGroupResponse_Dec().pyclass + +ReconfigureServiceConsoleReservationRequestMsg = ns0.ReconfigureServiceConsoleReservation_Dec().pyclass + +ReconfigureServiceConsoleReservationResponseMsg = ns0.ReconfigureServiceConsoleReservationResponse_Dec().pyclass + +ReconfigureVirtualMachineReservationRequestMsg = ns0.ReconfigureVirtualMachineReservation_Dec().pyclass + +ReconfigureVirtualMachineReservationResponseMsg = ns0.ReconfigureVirtualMachineReservationResponse_Dec().pyclass + +UpdateNetworkConfigRequestMsg = ns0.UpdateNetworkConfig_Dec().pyclass + +UpdateNetworkConfigResponseMsg = ns0.UpdateNetworkConfigResponse_Dec().pyclass + +UpdateDnsConfigRequestMsg = ns0.UpdateDnsConfig_Dec().pyclass + +UpdateDnsConfigResponseMsg = ns0.UpdateDnsConfigResponse_Dec().pyclass + +UpdateIpRouteConfigRequestMsg = ns0.UpdateIpRouteConfig_Dec().pyclass + +UpdateIpRouteConfigResponseMsg = ns0.UpdateIpRouteConfigResponse_Dec().pyclass + +UpdateConsoleIpRouteConfigRequestMsg = ns0.UpdateConsoleIpRouteConfig_Dec().pyclass + +UpdateConsoleIpRouteConfigResponseMsg = ns0.UpdateConsoleIpRouteConfigResponse_Dec().pyclass + +UpdateIpRouteTableConfigRequestMsg = ns0.UpdateIpRouteTableConfig_Dec().pyclass + +UpdateIpRouteTableConfigResponseMsg = ns0.UpdateIpRouteTableConfigResponse_Dec().pyclass + +AddVirtualSwitchRequestMsg = ns0.AddVirtualSwitch_Dec().pyclass + +AddVirtualSwitchResponseMsg = ns0.AddVirtualSwitchResponse_Dec().pyclass + +RemoveVirtualSwitchRequestMsg = ns0.RemoveVirtualSwitch_Dec().pyclass + +RemoveVirtualSwitchResponseMsg = ns0.RemoveVirtualSwitchResponse_Dec().pyclass + +UpdateVirtualSwitchRequestMsg = ns0.UpdateVirtualSwitch_Dec().pyclass + +UpdateVirtualSwitchResponseMsg = ns0.UpdateVirtualSwitchResponse_Dec().pyclass + +AddPortGroupRequestMsg = ns0.AddPortGroup_Dec().pyclass + +AddPortGroupResponseMsg = ns0.AddPortGroupResponse_Dec().pyclass + +RemovePortGroupRequestMsg = ns0.RemovePortGroup_Dec().pyclass + +RemovePortGroupResponseMsg = ns0.RemovePortGroupResponse_Dec().pyclass + +UpdatePortGroupRequestMsg = ns0.UpdatePortGroup_Dec().pyclass + +UpdatePortGroupResponseMsg = ns0.UpdatePortGroupResponse_Dec().pyclass + +UpdatePhysicalNicLinkSpeedRequestMsg = ns0.UpdatePhysicalNicLinkSpeed_Dec().pyclass + +UpdatePhysicalNicLinkSpeedResponseMsg = ns0.UpdatePhysicalNicLinkSpeedResponse_Dec().pyclass + +QueryNetworkHintRequestMsg = ns0.QueryNetworkHint_Dec().pyclass + +QueryNetworkHintResponseMsg = ns0.QueryNetworkHintResponse_Dec().pyclass + +AddVirtualNicRequestMsg = ns0.AddVirtualNic_Dec().pyclass + +AddVirtualNicResponseMsg = ns0.AddVirtualNicResponse_Dec().pyclass + +RemoveVirtualNicRequestMsg = ns0.RemoveVirtualNic_Dec().pyclass + +RemoveVirtualNicResponseMsg = ns0.RemoveVirtualNicResponse_Dec().pyclass + +UpdateVirtualNicRequestMsg = ns0.UpdateVirtualNic_Dec().pyclass + +UpdateVirtualNicResponseMsg = ns0.UpdateVirtualNicResponse_Dec().pyclass + +AddServiceConsoleVirtualNicRequestMsg = ns0.AddServiceConsoleVirtualNic_Dec().pyclass + +AddServiceConsoleVirtualNicResponseMsg = ns0.AddServiceConsoleVirtualNicResponse_Dec().pyclass + +RemoveServiceConsoleVirtualNicRequestMsg = ns0.RemoveServiceConsoleVirtualNic_Dec().pyclass + +RemoveServiceConsoleVirtualNicResponseMsg = ns0.RemoveServiceConsoleVirtualNicResponse_Dec().pyclass + +UpdateServiceConsoleVirtualNicRequestMsg = ns0.UpdateServiceConsoleVirtualNic_Dec().pyclass + +UpdateServiceConsoleVirtualNicResponseMsg = ns0.UpdateServiceConsoleVirtualNicResponse_Dec().pyclass + +RestartServiceConsoleVirtualNicRequestMsg = ns0.RestartServiceConsoleVirtualNic_Dec().pyclass + +RestartServiceConsoleVirtualNicResponseMsg = ns0.RestartServiceConsoleVirtualNicResponse_Dec().pyclass + +RefreshNetworkSystemRequestMsg = ns0.RefreshNetworkSystem_Dec().pyclass + +RefreshNetworkSystemResponseMsg = ns0.RefreshNetworkSystemResponse_Dec().pyclass + +CheckHostPatchRequestMsg = ns0.CheckHostPatch_Dec().pyclass + +CheckHostPatchResponseMsg = ns0.CheckHostPatchResponse_Dec().pyclass + +CheckHostPatch_TaskRequestMsg = ns0.CheckHostPatch_Task_Dec().pyclass + +CheckHostPatch_TaskResponseMsg = ns0.CheckHostPatch_TaskResponse_Dec().pyclass + +ScanHostPatchRequestMsg = ns0.ScanHostPatch_Dec().pyclass + +ScanHostPatchResponseMsg = ns0.ScanHostPatchResponse_Dec().pyclass + +ScanHostPatch_TaskRequestMsg = ns0.ScanHostPatch_Task_Dec().pyclass + +ScanHostPatch_TaskResponseMsg = ns0.ScanHostPatch_TaskResponse_Dec().pyclass + +ScanHostPatchV2RequestMsg = ns0.ScanHostPatchV2_Dec().pyclass + +ScanHostPatchV2ResponseMsg = ns0.ScanHostPatchV2Response_Dec().pyclass + +ScanHostPatchV2_TaskRequestMsg = ns0.ScanHostPatchV2_Task_Dec().pyclass + +ScanHostPatchV2_TaskResponseMsg = ns0.ScanHostPatchV2_TaskResponse_Dec().pyclass + +StageHostPatchRequestMsg = ns0.StageHostPatch_Dec().pyclass + +StageHostPatchResponseMsg = ns0.StageHostPatchResponse_Dec().pyclass + +StageHostPatch_TaskRequestMsg = ns0.StageHostPatch_Task_Dec().pyclass + +StageHostPatch_TaskResponseMsg = ns0.StageHostPatch_TaskResponse_Dec().pyclass + +InstallHostPatchRequestMsg = ns0.InstallHostPatch_Dec().pyclass + +InstallHostPatchResponseMsg = ns0.InstallHostPatchResponse_Dec().pyclass + +InstallHostPatch_TaskRequestMsg = ns0.InstallHostPatch_Task_Dec().pyclass + +InstallHostPatch_TaskResponseMsg = ns0.InstallHostPatch_TaskResponse_Dec().pyclass + +InstallHostPatchV2RequestMsg = ns0.InstallHostPatchV2_Dec().pyclass + +InstallHostPatchV2ResponseMsg = ns0.InstallHostPatchV2Response_Dec().pyclass + +InstallHostPatchV2_TaskRequestMsg = ns0.InstallHostPatchV2_Task_Dec().pyclass + +InstallHostPatchV2_TaskResponseMsg = ns0.InstallHostPatchV2_TaskResponse_Dec().pyclass + +UninstallHostPatchRequestMsg = ns0.UninstallHostPatch_Dec().pyclass + +UninstallHostPatchResponseMsg = ns0.UninstallHostPatchResponse_Dec().pyclass + +UninstallHostPatch_TaskRequestMsg = ns0.UninstallHostPatch_Task_Dec().pyclass + +UninstallHostPatch_TaskResponseMsg = ns0.UninstallHostPatch_TaskResponse_Dec().pyclass + +QueryHostPatchRequestMsg = ns0.QueryHostPatch_Dec().pyclass + +QueryHostPatchResponseMsg = ns0.QueryHostPatchResponse_Dec().pyclass + +QueryHostPatch_TaskRequestMsg = ns0.QueryHostPatch_Task_Dec().pyclass + +QueryHostPatch_TaskResponseMsg = ns0.QueryHostPatch_TaskResponse_Dec().pyclass + +RefreshRequestMsg = ns0.Refresh_Dec().pyclass + +RefreshResponseMsg = ns0.RefreshResponse_Dec().pyclass + +UpdatePassthruConfigRequestMsg = ns0.UpdatePassthruConfig_Dec().pyclass + +UpdatePassthruConfigResponseMsg = ns0.UpdatePassthruConfigResponse_Dec().pyclass + +UpdateServicePolicyRequestMsg = ns0.UpdateServicePolicy_Dec().pyclass + +UpdateServicePolicyResponseMsg = ns0.UpdateServicePolicyResponse_Dec().pyclass + +StartServiceRequestMsg = ns0.StartService_Dec().pyclass + +StartServiceResponseMsg = ns0.StartServiceResponse_Dec().pyclass + +StopServiceRequestMsg = ns0.StopService_Dec().pyclass + +StopServiceResponseMsg = ns0.StopServiceResponse_Dec().pyclass + +RestartServiceRequestMsg = ns0.RestartService_Dec().pyclass + +RestartServiceResponseMsg = ns0.RestartServiceResponse_Dec().pyclass + +UninstallServiceRequestMsg = ns0.UninstallService_Dec().pyclass + +UninstallServiceResponseMsg = ns0.UninstallServiceResponse_Dec().pyclass + +RefreshServicesRequestMsg = ns0.RefreshServices_Dec().pyclass + +RefreshServicesResponseMsg = ns0.RefreshServicesResponse_Dec().pyclass + +ReconfigureSnmpAgentRequestMsg = ns0.ReconfigureSnmpAgent_Dec().pyclass + +ReconfigureSnmpAgentResponseMsg = ns0.ReconfigureSnmpAgentResponse_Dec().pyclass + +SendTestNotificationRequestMsg = ns0.SendTestNotification_Dec().pyclass + +SendTestNotificationResponseMsg = ns0.SendTestNotificationResponse_Dec().pyclass + +RetrieveDiskPartitionInfoRequestMsg = ns0.RetrieveDiskPartitionInfo_Dec().pyclass + +RetrieveDiskPartitionInfoResponseMsg = ns0.RetrieveDiskPartitionInfoResponse_Dec().pyclass + +ComputeDiskPartitionInfoRequestMsg = ns0.ComputeDiskPartitionInfo_Dec().pyclass + +ComputeDiskPartitionInfoResponseMsg = ns0.ComputeDiskPartitionInfoResponse_Dec().pyclass + +ComputeDiskPartitionInfoForResizeRequestMsg = ns0.ComputeDiskPartitionInfoForResize_Dec().pyclass + +ComputeDiskPartitionInfoForResizeResponseMsg = ns0.ComputeDiskPartitionInfoForResizeResponse_Dec().pyclass + +UpdateDiskPartitionsRequestMsg = ns0.UpdateDiskPartitions_Dec().pyclass + +UpdateDiskPartitionsResponseMsg = ns0.UpdateDiskPartitionsResponse_Dec().pyclass + +FormatVmfsRequestMsg = ns0.FormatVmfs_Dec().pyclass + +FormatVmfsResponseMsg = ns0.FormatVmfsResponse_Dec().pyclass + +RescanVmfsRequestMsg = ns0.RescanVmfs_Dec().pyclass + +RescanVmfsResponseMsg = ns0.RescanVmfsResponse_Dec().pyclass + +AttachVmfsExtentRequestMsg = ns0.AttachVmfsExtent_Dec().pyclass + +AttachVmfsExtentResponseMsg = ns0.AttachVmfsExtentResponse_Dec().pyclass + +ExpandVmfsExtentRequestMsg = ns0.ExpandVmfsExtent_Dec().pyclass + +ExpandVmfsExtentResponseMsg = ns0.ExpandVmfsExtentResponse_Dec().pyclass + +UpgradeVmfsRequestMsg = ns0.UpgradeVmfs_Dec().pyclass + +UpgradeVmfsResponseMsg = ns0.UpgradeVmfsResponse_Dec().pyclass + +UpgradeVmLayoutRequestMsg = ns0.UpgradeVmLayout_Dec().pyclass + +UpgradeVmLayoutResponseMsg = ns0.UpgradeVmLayoutResponse_Dec().pyclass + +QueryUnresolvedVmfsVolumeRequestMsg = ns0.QueryUnresolvedVmfsVolume_Dec().pyclass + +QueryUnresolvedVmfsVolumeResponseMsg = ns0.QueryUnresolvedVmfsVolumeResponse_Dec().pyclass + +ResolveMultipleUnresolvedVmfsVolumesRequestMsg = ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec().pyclass + +ResolveMultipleUnresolvedVmfsVolumesResponseMsg = ns0.ResolveMultipleUnresolvedVmfsVolumesResponse_Dec().pyclass + +UnmountForceMountedVmfsVolumeRequestMsg = ns0.UnmountForceMountedVmfsVolume_Dec().pyclass + +UnmountForceMountedVmfsVolumeResponseMsg = ns0.UnmountForceMountedVmfsVolumeResponse_Dec().pyclass + +RescanHbaRequestMsg = ns0.RescanHba_Dec().pyclass + +RescanHbaResponseMsg = ns0.RescanHbaResponse_Dec().pyclass + +RescanAllHbaRequestMsg = ns0.RescanAllHba_Dec().pyclass + +RescanAllHbaResponseMsg = ns0.RescanAllHbaResponse_Dec().pyclass + +UpdateSoftwareInternetScsiEnabledRequestMsg = ns0.UpdateSoftwareInternetScsiEnabled_Dec().pyclass + +UpdateSoftwareInternetScsiEnabledResponseMsg = ns0.UpdateSoftwareInternetScsiEnabledResponse_Dec().pyclass + +UpdateInternetScsiDiscoveryPropertiesRequestMsg = ns0.UpdateInternetScsiDiscoveryProperties_Dec().pyclass + +UpdateInternetScsiDiscoveryPropertiesResponseMsg = ns0.UpdateInternetScsiDiscoveryPropertiesResponse_Dec().pyclass + +UpdateInternetScsiAuthenticationPropertiesRequestMsg = ns0.UpdateInternetScsiAuthenticationProperties_Dec().pyclass + +UpdateInternetScsiAuthenticationPropertiesResponseMsg = ns0.UpdateInternetScsiAuthenticationPropertiesResponse_Dec().pyclass + +UpdateInternetScsiDigestPropertiesRequestMsg = ns0.UpdateInternetScsiDigestProperties_Dec().pyclass + +UpdateInternetScsiDigestPropertiesResponseMsg = ns0.UpdateInternetScsiDigestPropertiesResponse_Dec().pyclass + +UpdateInternetScsiAdvancedOptionsRequestMsg = ns0.UpdateInternetScsiAdvancedOptions_Dec().pyclass + +UpdateInternetScsiAdvancedOptionsResponseMsg = ns0.UpdateInternetScsiAdvancedOptionsResponse_Dec().pyclass + +UpdateInternetScsiIPPropertiesRequestMsg = ns0.UpdateInternetScsiIPProperties_Dec().pyclass + +UpdateInternetScsiIPPropertiesResponseMsg = ns0.UpdateInternetScsiIPPropertiesResponse_Dec().pyclass + +UpdateInternetScsiNameRequestMsg = ns0.UpdateInternetScsiName_Dec().pyclass + +UpdateInternetScsiNameResponseMsg = ns0.UpdateInternetScsiNameResponse_Dec().pyclass + +UpdateInternetScsiAliasRequestMsg = ns0.UpdateInternetScsiAlias_Dec().pyclass + +UpdateInternetScsiAliasResponseMsg = ns0.UpdateInternetScsiAliasResponse_Dec().pyclass + +AddInternetScsiSendTargetsRequestMsg = ns0.AddInternetScsiSendTargets_Dec().pyclass + +AddInternetScsiSendTargetsResponseMsg = ns0.AddInternetScsiSendTargetsResponse_Dec().pyclass + +RemoveInternetScsiSendTargetsRequestMsg = ns0.RemoveInternetScsiSendTargets_Dec().pyclass + +RemoveInternetScsiSendTargetsResponseMsg = ns0.RemoveInternetScsiSendTargetsResponse_Dec().pyclass + +AddInternetScsiStaticTargetsRequestMsg = ns0.AddInternetScsiStaticTargets_Dec().pyclass + +AddInternetScsiStaticTargetsResponseMsg = ns0.AddInternetScsiStaticTargetsResponse_Dec().pyclass + +RemoveInternetScsiStaticTargetsRequestMsg = ns0.RemoveInternetScsiStaticTargets_Dec().pyclass + +RemoveInternetScsiStaticTargetsResponseMsg = ns0.RemoveInternetScsiStaticTargetsResponse_Dec().pyclass + +EnableMultipathPathRequestMsg = ns0.EnableMultipathPath_Dec().pyclass + +EnableMultipathPathResponseMsg = ns0.EnableMultipathPathResponse_Dec().pyclass + +DisableMultipathPathRequestMsg = ns0.DisableMultipathPath_Dec().pyclass + +DisableMultipathPathResponseMsg = ns0.DisableMultipathPathResponse_Dec().pyclass + +SetMultipathLunPolicyRequestMsg = ns0.SetMultipathLunPolicy_Dec().pyclass + +SetMultipathLunPolicyResponseMsg = ns0.SetMultipathLunPolicyResponse_Dec().pyclass + +QueryPathSelectionPolicyOptionsRequestMsg = ns0.QueryPathSelectionPolicyOptions_Dec().pyclass + +QueryPathSelectionPolicyOptionsResponseMsg = ns0.QueryPathSelectionPolicyOptionsResponse_Dec().pyclass + +QueryStorageArrayTypePolicyOptionsRequestMsg = ns0.QueryStorageArrayTypePolicyOptions_Dec().pyclass + +QueryStorageArrayTypePolicyOptionsResponseMsg = ns0.QueryStorageArrayTypePolicyOptionsResponse_Dec().pyclass + +UpdateScsiLunDisplayNameRequestMsg = ns0.UpdateScsiLunDisplayName_Dec().pyclass + +UpdateScsiLunDisplayNameResponseMsg = ns0.UpdateScsiLunDisplayNameResponse_Dec().pyclass + +RefreshStorageSystemRequestMsg = ns0.RefreshStorageSystem_Dec().pyclass + +RefreshStorageSystemResponseMsg = ns0.RefreshStorageSystemResponse_Dec().pyclass + +UpdateIpConfigRequestMsg = ns0.UpdateIpConfig_Dec().pyclass + +UpdateIpConfigResponseMsg = ns0.UpdateIpConfigResponse_Dec().pyclass + +SelectVnicRequestMsg = ns0.SelectVnic_Dec().pyclass + +SelectVnicResponseMsg = ns0.SelectVnicResponse_Dec().pyclass + +DeselectVnicRequestMsg = ns0.DeselectVnic_Dec().pyclass + +DeselectVnicResponseMsg = ns0.DeselectVnicResponse_Dec().pyclass + +QueryNetConfigRequestMsg = ns0.QueryNetConfig_Dec().pyclass + +QueryNetConfigResponseMsg = ns0.QueryNetConfigResponse_Dec().pyclass + +VirtualNicManagerSelectVnicRequestMsg = ns0.VirtualNicManagerSelectVnic_Dec().pyclass + +VirtualNicManagerSelectVnicResponseMsg = ns0.VirtualNicManagerSelectVnicResponse_Dec().pyclass + +VirtualNicManagerDeselectVnicRequestMsg = ns0.VirtualNicManagerDeselectVnic_Dec().pyclass + +VirtualNicManagerDeselectVnicResponseMsg = ns0.VirtualNicManagerDeselectVnicResponse_Dec().pyclass + +QueryOptionsRequestMsg = ns0.QueryOptions_Dec().pyclass + +QueryOptionsResponseMsg = ns0.QueryOptionsResponse_Dec().pyclass + +UpdateOptionsRequestMsg = ns0.UpdateOptions_Dec().pyclass + +UpdateOptionsResponseMsg = ns0.UpdateOptionsResponse_Dec().pyclass + +ComplianceManagerCheckComplianceRequestMsg = ns0.ComplianceManagerCheckCompliance_Dec().pyclass + +ComplianceManagerCheckComplianceResponseMsg = ns0.ComplianceManagerCheckComplianceResponse_Dec().pyclass + +ComplianceManagerCheckCompliance_TaskRequestMsg = ns0.ComplianceManagerCheckCompliance_Task_Dec().pyclass + +ComplianceManagerCheckCompliance_TaskResponseMsg = ns0.ComplianceManagerCheckCompliance_TaskResponse_Dec().pyclass + +ComplianceManagerQueryComplianceStatusRequestMsg = ns0.ComplianceManagerQueryComplianceStatus_Dec().pyclass + +ComplianceManagerQueryComplianceStatusResponseMsg = ns0.ComplianceManagerQueryComplianceStatusResponse_Dec().pyclass + +ComplianceManagerClearComplianceStatusRequestMsg = ns0.ComplianceManagerClearComplianceStatus_Dec().pyclass + +ComplianceManagerClearComplianceStatusResponseMsg = ns0.ComplianceManagerClearComplianceStatusResponse_Dec().pyclass + +ComplianceManagerQueryExpressionMetadataRequestMsg = ns0.ComplianceManagerQueryExpressionMetadata_Dec().pyclass + +ComplianceManagerQueryExpressionMetadataResponseMsg = ns0.ComplianceManagerQueryExpressionMetadataResponse_Dec().pyclass + +ProfileDestroyRequestMsg = ns0.ProfileDestroy_Dec().pyclass + +ProfileDestroyResponseMsg = ns0.ProfileDestroyResponse_Dec().pyclass + +ProfileAssociateRequestMsg = ns0.ProfileAssociate_Dec().pyclass + +ProfileAssociateResponseMsg = ns0.ProfileAssociateResponse_Dec().pyclass + +ProfileDissociateRequestMsg = ns0.ProfileDissociate_Dec().pyclass + +ProfileDissociateResponseMsg = ns0.ProfileDissociateResponse_Dec().pyclass + +ProfileCheckComplianceRequestMsg = ns0.ProfileCheckCompliance_Dec().pyclass + +ProfileCheckComplianceResponseMsg = ns0.ProfileCheckComplianceResponse_Dec().pyclass + +ProfileCheckCompliance_TaskRequestMsg = ns0.ProfileCheckCompliance_Task_Dec().pyclass + +ProfileCheckCompliance_TaskResponseMsg = ns0.ProfileCheckCompliance_TaskResponse_Dec().pyclass + +ProfileExportProfileRequestMsg = ns0.ProfileExportProfile_Dec().pyclass + +ProfileExportProfileResponseMsg = ns0.ProfileExportProfileResponse_Dec().pyclass + +CreateProfileRequestMsg = ns0.CreateProfile_Dec().pyclass + +CreateProfileResponseMsg = ns0.CreateProfileResponse_Dec().pyclass + +ProfileQueryPolicyMetadataRequestMsg = ns0.ProfileQueryPolicyMetadata_Dec().pyclass + +ProfileQueryPolicyMetadataResponseMsg = ns0.ProfileQueryPolicyMetadataResponse_Dec().pyclass + +ProfileFindAssociatedProfileRequestMsg = ns0.ProfileFindAssociatedProfile_Dec().pyclass + +ProfileFindAssociatedProfileResponseMsg = ns0.ProfileFindAssociatedProfileResponse_Dec().pyclass + +ClusterProfileUpdateRequestMsg = ns0.ClusterProfileUpdate_Dec().pyclass + +ClusterProfileUpdateResponseMsg = ns0.ClusterProfileUpdateResponse_Dec().pyclass + +HostProfileUpdateReferenceHostRequestMsg = ns0.HostProfileUpdateReferenceHost_Dec().pyclass + +HostProfileUpdateReferenceHostResponseMsg = ns0.HostProfileUpdateReferenceHostResponse_Dec().pyclass + +HostProfileUpdateRequestMsg = ns0.HostProfileUpdate_Dec().pyclass + +HostProfileUpdateResponseMsg = ns0.HostProfileUpdateResponse_Dec().pyclass + +HostProfileExecuteRequestMsg = ns0.HostProfileExecute_Dec().pyclass + +HostProfileExecuteResponseMsg = ns0.HostProfileExecuteResponse_Dec().pyclass + +HostProfileApplyRequestMsg = ns0.HostProfileApply_Dec().pyclass + +HostProfileApplyResponseMsg = ns0.HostProfileApplyResponse_Dec().pyclass + +HostProfileApply_TaskRequestMsg = ns0.HostProfileApply_Task_Dec().pyclass + +HostProfileApply_TaskResponseMsg = ns0.HostProfileApply_TaskResponse_Dec().pyclass + +HostProfileGenerateConfigTaskListRequestMsg = ns0.HostProfileGenerateConfigTaskList_Dec().pyclass + +HostProfileGenerateConfigTaskListResponseMsg = ns0.HostProfileGenerateConfigTaskListResponse_Dec().pyclass + +HostProfileQueryProfileMetadataRequestMsg = ns0.HostProfileQueryProfileMetadata_Dec().pyclass + +HostProfileQueryProfileMetadataResponseMsg = ns0.HostProfileQueryProfileMetadataResponse_Dec().pyclass + +HostProfileCreateDefaultProfileRequestMsg = ns0.HostProfileCreateDefaultProfile_Dec().pyclass + +HostProfileCreateDefaultProfileResponseMsg = ns0.HostProfileCreateDefaultProfileResponse_Dec().pyclass + +RemoveScheduledTaskRequestMsg = ns0.RemoveScheduledTask_Dec().pyclass + +RemoveScheduledTaskResponseMsg = ns0.RemoveScheduledTaskResponse_Dec().pyclass + +ReconfigureScheduledTaskRequestMsg = ns0.ReconfigureScheduledTask_Dec().pyclass + +ReconfigureScheduledTaskResponseMsg = ns0.ReconfigureScheduledTaskResponse_Dec().pyclass + +RunScheduledTaskRequestMsg = ns0.RunScheduledTask_Dec().pyclass + +RunScheduledTaskResponseMsg = ns0.RunScheduledTaskResponse_Dec().pyclass + +CreateScheduledTaskRequestMsg = ns0.CreateScheduledTask_Dec().pyclass + +CreateScheduledTaskResponseMsg = ns0.CreateScheduledTaskResponse_Dec().pyclass + +RetrieveEntityScheduledTaskRequestMsg = ns0.RetrieveEntityScheduledTask_Dec().pyclass + +RetrieveEntityScheduledTaskResponseMsg = ns0.RetrieveEntityScheduledTaskResponse_Dec().pyclass + +CreateObjectScheduledTaskRequestMsg = ns0.CreateObjectScheduledTask_Dec().pyclass + +CreateObjectScheduledTaskResponseMsg = ns0.CreateObjectScheduledTaskResponse_Dec().pyclass + +RetrieveObjectScheduledTaskRequestMsg = ns0.RetrieveObjectScheduledTask_Dec().pyclass + +RetrieveObjectScheduledTaskResponseMsg = ns0.RetrieveObjectScheduledTaskResponse_Dec().pyclass + +OpenInventoryViewFolderRequestMsg = ns0.OpenInventoryViewFolder_Dec().pyclass + +OpenInventoryViewFolderResponseMsg = ns0.OpenInventoryViewFolderResponse_Dec().pyclass + +CloseInventoryViewFolderRequestMsg = ns0.CloseInventoryViewFolder_Dec().pyclass + +CloseInventoryViewFolderResponseMsg = ns0.CloseInventoryViewFolderResponse_Dec().pyclass + +ModifyListViewRequestMsg = ns0.ModifyListView_Dec().pyclass + +ModifyListViewResponseMsg = ns0.ModifyListViewResponse_Dec().pyclass + +ResetListViewRequestMsg = ns0.ResetListView_Dec().pyclass + +ResetListViewResponseMsg = ns0.ResetListViewResponse_Dec().pyclass + +ResetListViewFromViewRequestMsg = ns0.ResetListViewFromView_Dec().pyclass + +ResetListViewFromViewResponseMsg = ns0.ResetListViewFromViewResponse_Dec().pyclass + +DestroyViewRequestMsg = ns0.DestroyView_Dec().pyclass + +DestroyViewResponseMsg = ns0.DestroyViewResponse_Dec().pyclass + +CreateInventoryViewRequestMsg = ns0.CreateInventoryView_Dec().pyclass + +CreateInventoryViewResponseMsg = ns0.CreateInventoryViewResponse_Dec().pyclass + +CreateContainerViewRequestMsg = ns0.CreateContainerView_Dec().pyclass + +CreateContainerViewResponseMsg = ns0.CreateContainerViewResponse_Dec().pyclass + +CreateListViewRequestMsg = ns0.CreateListView_Dec().pyclass + +CreateListViewResponseMsg = ns0.CreateListViewResponse_Dec().pyclass + +CreateListViewFromViewRequestMsg = ns0.CreateListViewFromView_Dec().pyclass + +CreateListViewFromViewResponseMsg = ns0.CreateListViewFromViewResponse_Dec().pyclass + +RevertToSnapshotRequestMsg = ns0.RevertToSnapshot_Dec().pyclass + +RevertToSnapshotResponseMsg = ns0.RevertToSnapshotResponse_Dec().pyclass + +RevertToSnapshot_TaskRequestMsg = ns0.RevertToSnapshot_Task_Dec().pyclass + +RevertToSnapshot_TaskResponseMsg = ns0.RevertToSnapshot_TaskResponse_Dec().pyclass + +RemoveSnapshotRequestMsg = ns0.RemoveSnapshot_Dec().pyclass + +RemoveSnapshotResponseMsg = ns0.RemoveSnapshotResponse_Dec().pyclass + +RemoveSnapshot_TaskRequestMsg = ns0.RemoveSnapshot_Task_Dec().pyclass + +RemoveSnapshot_TaskResponseMsg = ns0.RemoveSnapshot_TaskResponse_Dec().pyclass + +RenameSnapshotRequestMsg = ns0.RenameSnapshot_Dec().pyclass + +RenameSnapshotResponseMsg = ns0.RenameSnapshotResponse_Dec().pyclass + +CheckCompatibilityRequestMsg = ns0.CheckCompatibility_Dec().pyclass + +CheckCompatibilityResponseMsg = ns0.CheckCompatibilityResponse_Dec().pyclass + +CheckCompatibility_TaskRequestMsg = ns0.CheckCompatibility_Task_Dec().pyclass + +CheckCompatibility_TaskResponseMsg = ns0.CheckCompatibility_TaskResponse_Dec().pyclass + +QueryVMotionCompatibilityExRequestMsg = ns0.QueryVMotionCompatibilityEx_Dec().pyclass + +QueryVMotionCompatibilityExResponseMsg = ns0.QueryVMotionCompatibilityExResponse_Dec().pyclass + +QueryVMotionCompatibilityEx_TaskRequestMsg = ns0.QueryVMotionCompatibilityEx_Task_Dec().pyclass + +QueryVMotionCompatibilityEx_TaskResponseMsg = ns0.QueryVMotionCompatibilityEx_TaskResponse_Dec().pyclass + +CheckMigrateRequestMsg = ns0.CheckMigrate_Dec().pyclass + +CheckMigrateResponseMsg = ns0.CheckMigrateResponse_Dec().pyclass + +CheckMigrate_TaskRequestMsg = ns0.CheckMigrate_Task_Dec().pyclass + +CheckMigrate_TaskResponseMsg = ns0.CheckMigrate_TaskResponse_Dec().pyclass + +CheckRelocateRequestMsg = ns0.CheckRelocate_Dec().pyclass + +CheckRelocateResponseMsg = ns0.CheckRelocateResponse_Dec().pyclass + +CheckRelocate_TaskRequestMsg = ns0.CheckRelocate_Task_Dec().pyclass + +CheckRelocate_TaskResponseMsg = ns0.CheckRelocate_TaskResponse_Dec().pyclass diff --git a/nova/virt/vmwareapi/VimService_services_types.py b/nova/virt/vmwareapi/VimService_services_types.py new file mode 100644 index 000000000..f06ac99c9 --- /dev/null +++ b/nova/virt/vmwareapi/VimService_services_types.py @@ -0,0 +1,72377 @@ +################################################## +# VimService_services_types.py +# generated by ZSI.generate.wsdl2python +################################################## + + +import ZSI +import ZSI.TCcompound +from ZSI.schema import LocalElementDeclaration, ElementDeclaration, TypeDefinition, GTD, GED +from ZSI.generate.pyclass import pyclass_type + +############################## +# targetNamespace +# urn:vim25 +############################## + +class ns0: + targetNamespace = "urn:vim25" + + class DynamicArray_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DynamicArray") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DynamicArray_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"dynamicType"), aname="_dynamicType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"val"), aname="_val", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._dynamicType = None + self._val = [] + return + Holder.__name__ = "DynamicArray_Holder" + self.pyclass = Holder + + class DynamicData_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DynamicData") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DynamicData_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"dynamicType"), aname="_dynamicType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"dynamicProperty"), aname="_dynamicProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._dynamicType = None + self._dynamicProperty = [] + return + Holder.__name__ = "DynamicData_Holder" + self.pyclass = Holder + + class DynamicProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DynamicProperty") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DynamicProperty_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"val"), aname="_val", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._name = None + self._val = None + return + Holder.__name__ = "DynamicProperty_Holder" + self.pyclass = Holder + + class ArrayOfDynamicProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDynamicProperty") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDynamicProperty_Def.schema + TClist = [GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"DynamicProperty"), aname="_DynamicProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DynamicProperty = [] + return + Holder.__name__ = "ArrayOfDynamicProperty_Holder" + self.pyclass = Holder + + class KeyAnyValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "KeyAnyValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.KeyAnyValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.KeyAnyValue_Def.__bases__: + bases = list(ns0.KeyAnyValue_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.KeyAnyValue_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfKeyAnyValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfKeyAnyValue") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfKeyAnyValue_Def.schema + TClist = [GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"KeyAnyValue"), aname="_KeyAnyValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._KeyAnyValue = [] + return + Holder.__name__ = "ArrayOfKeyAnyValue_Holder" + self.pyclass = Holder + + class LocalizableMessage_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LocalizableMessage") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LocalizableMessage_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"arg"), aname="_arg", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LocalizableMessage_Def.__bases__: + bases = list(ns0.LocalizableMessage_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LocalizableMessage_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLocalizableMessage_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLocalizableMessage") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLocalizableMessage_Def.schema + TClist = [GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"LocalizableMessage"), aname="_LocalizableMessage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LocalizableMessage = [] + return + Holder.__name__ = "ArrayOfLocalizableMessage_Holder" + self.pyclass = Holder + + class HostCommunication_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCommunication") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCommunication_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.HostCommunication_Def.__bases__: + bases = list(ns0.HostCommunication_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.HostCommunication_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNotConnected_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNotConnected") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNotConnected_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostCommunication_Def not in ns0.HostNotConnected_Def.__bases__: + bases = list(ns0.HostNotConnected_Def.__bases__) + bases.insert(0, ns0.HostCommunication_Def) + ns0.HostNotConnected_Def.__bases__ = tuple(bases) + + ns0.HostCommunication_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNotReachable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNotReachable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNotReachable_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostCommunication_Def not in ns0.HostNotReachable_Def.__bases__: + bases = list(ns0.HostNotReachable_Def.__bases__) + bases.insert(0, ns0.HostCommunication_Def) + ns0.HostNotReachable_Def.__bases__ = tuple(bases) + + ns0.HostCommunication_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidArgument_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"invalidProperty"), aname="_invalidProperty", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.InvalidArgument_Def.__bases__: + bases = list(ns0.InvalidArgument_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.InvalidArgument_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidRequest_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidRequest") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidRequest_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.InvalidRequest_Def.__bases__: + bases = list(ns0.InvalidRequest_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.InvalidRequest_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidType_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidRequest_Def not in ns0.InvalidType_Def.__bases__: + bases = list(ns0.InvalidType_Def.__bases__) + bases.insert(0, ns0.InvalidRequest_Def) + ns0.InvalidType_Def.__bases__ = tuple(bases) + + ns0.InvalidRequest_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ManagedObjectNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ManagedObjectNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ManagedObjectNotFound_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.ManagedObjectNotFound_Def.__bases__: + bases = list(ns0.ManagedObjectNotFound_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.ManagedObjectNotFound_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MethodNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MethodNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MethodNotFound_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"receiver"), aname="_receiver", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"method"), aname="_method", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidRequest_Def not in ns0.MethodNotFound_Def.__bases__: + bases = list(ns0.MethodNotFound_Def.__bases__) + bases.insert(0, ns0.InvalidRequest_Def) + ns0.MethodNotFound_Def.__bases__ = tuple(bases) + + ns0.InvalidRequest_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotEnoughLicenses_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotEnoughLicenses") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotEnoughLicenses_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.NotEnoughLicenses_Def.__bases__: + bases = list(ns0.NotEnoughLicenses_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.NotEnoughLicenses_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotImplemented_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotImplemented") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotImplemented_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.NotImplemented_Def.__bases__: + bases = list(ns0.NotImplemented_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.NotImplemented_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.NotSupported_Def.__bases__: + bases = list(ns0.NotSupported_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.NotSupported_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RequestCanceled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RequestCanceled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RequestCanceled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.RequestCanceled_Def.__bases__: + bases = list(ns0.RequestCanceled_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.RequestCanceled_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SecurityError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SecurityError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SecurityError_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.SecurityError_Def.__bases__: + bases = list(ns0.SecurityError_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.SecurityError_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SystemError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SystemError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SystemError_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.SystemError_Def.__bases__: + bases = list(ns0.SystemError_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.SystemError_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnexpectedFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnexpectedFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnexpectedFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"faultName"), aname="_faultName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.UnexpectedFault_Def.__bases__: + bases = list(ns0.UnexpectedFault_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.UnexpectedFault_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidCollectorVersion_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidCollectorVersion") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidCollectorVersion_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MethodFault_Def not in ns0.InvalidCollectorVersion_Def.__bases__: + bases = list(ns0.InvalidCollectorVersion_Def.__bases__) + bases.insert(0, ns0.MethodFault_Def) + ns0.InvalidCollectorVersion_Def.__bases__ = tuple(bases) + + ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidProperty_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidProperty") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidProperty_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MethodFault_Def not in ns0.InvalidProperty_Def.__bases__: + bases = list(ns0.InvalidProperty_Def.__bases__) + bases.insert(0, ns0.MethodFault_Def) + ns0.InvalidProperty_Def.__bases__ = tuple(bases) + + ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PropertyFilterSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PropertyFilterSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PropertyFilterSpec_Def.schema + TClist = [GTD("urn:vim25","PropertySpec",lazy=True)(pname=(ns,"propSet"), aname="_propSet", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ObjectSpec",lazy=True)(pname=(ns,"objectSet"), aname="_objectSet", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PropertyFilterSpec_Def.__bases__: + bases = list(ns0.PropertyFilterSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PropertyFilterSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPropertyFilterSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPropertyFilterSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPropertyFilterSpec_Def.schema + TClist = [GTD("urn:vim25","PropertyFilterSpec",lazy=True)(pname=(ns,"PropertyFilterSpec"), aname="_PropertyFilterSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PropertyFilterSpec = [] + return + Holder.__name__ = "ArrayOfPropertyFilterSpec_Holder" + self.pyclass = Holder + + class PropertySpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PropertySpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PropertySpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"all"), aname="_all", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathSet"), aname="_pathSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PropertySpec_Def.__bases__: + bases = list(ns0.PropertySpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PropertySpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPropertySpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPropertySpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPropertySpec_Def.schema + TClist = [GTD("urn:vim25","PropertySpec",lazy=True)(pname=(ns,"PropertySpec"), aname="_PropertySpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PropertySpec = [] + return + Holder.__name__ = "ArrayOfPropertySpec_Holder" + self.pyclass = Holder + + class ObjectSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ObjectSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ObjectSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"skip"), aname="_skip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SelectionSpec",lazy=True)(pname=(ns,"selectSet"), aname="_selectSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ObjectSpec_Def.__bases__: + bases = list(ns0.ObjectSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ObjectSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfObjectSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfObjectSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfObjectSpec_Def.schema + TClist = [GTD("urn:vim25","ObjectSpec",lazy=True)(pname=(ns,"ObjectSpec"), aname="_ObjectSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ObjectSpec = [] + return + Holder.__name__ = "ArrayOfObjectSpec_Holder" + self.pyclass = Holder + + class SelectionSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SelectionSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SelectionSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.SelectionSpec_Def.__bases__: + bases = list(ns0.SelectionSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.SelectionSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfSelectionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfSelectionSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfSelectionSpec_Def.schema + TClist = [GTD("urn:vim25","SelectionSpec",lazy=True)(pname=(ns,"SelectionSpec"), aname="_SelectionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._SelectionSpec = [] + return + Holder.__name__ = "ArrayOfSelectionSpec_Holder" + self.pyclass = Holder + + class TraversalSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TraversalSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TraversalSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"skip"), aname="_skip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SelectionSpec",lazy=True)(pname=(ns,"selectSet"), aname="_selectSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SelectionSpec_Def not in ns0.TraversalSpec_Def.__bases__: + bases = list(ns0.TraversalSpec_Def.__bases__) + bases.insert(0, ns0.SelectionSpec_Def) + ns0.TraversalSpec_Def.__bases__ = tuple(bases) + + ns0.SelectionSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DestroyPropertyFilterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyPropertyFilterRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyPropertyFilterRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DestroyPropertyFilterRequestType_Holder" + self.pyclass = Holder + + class ObjectContent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ObjectContent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ObjectContent_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"propSet"), aname="_propSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MissingProperty",lazy=True)(pname=(ns,"missingSet"), aname="_missingSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ObjectContent_Def.__bases__: + bases = list(ns0.ObjectContent_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ObjectContent_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfObjectContent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfObjectContent") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfObjectContent_Def.schema + TClist = [GTD("urn:vim25","ObjectContent",lazy=True)(pname=(ns,"ObjectContent"), aname="_ObjectContent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ObjectContent = [] + return + Holder.__name__ = "ArrayOfObjectContent_Holder" + self.pyclass = Holder + + class UpdateSet_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UpdateSet") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UpdateSet_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyFilterUpdate",lazy=True)(pname=(ns,"filterSet"), aname="_filterSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.UpdateSet_Def.__bases__: + bases = list(ns0.UpdateSet_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.UpdateSet_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PropertyFilterUpdate_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PropertyFilterUpdate") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PropertyFilterUpdate_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ObjectUpdate",lazy=True)(pname=(ns,"objectSet"), aname="_objectSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MissingObject",lazy=True)(pname=(ns,"missingSet"), aname="_missingSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PropertyFilterUpdate_Def.__bases__: + bases = list(ns0.PropertyFilterUpdate_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PropertyFilterUpdate_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPropertyFilterUpdate_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPropertyFilterUpdate") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPropertyFilterUpdate_Def.schema + TClist = [GTD("urn:vim25","PropertyFilterUpdate",lazy=True)(pname=(ns,"PropertyFilterUpdate"), aname="_PropertyFilterUpdate", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PropertyFilterUpdate = [] + return + Holder.__name__ = "ArrayOfPropertyFilterUpdate_Holder" + self.pyclass = Holder + + class ObjectUpdateKind_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ObjectUpdateKind") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ObjectUpdate_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ObjectUpdate") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ObjectUpdate_Def.schema + TClist = [GTD("urn:vim25","ObjectUpdateKind",lazy=True)(pname=(ns,"kind"), aname="_kind", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyChange",lazy=True)(pname=(ns,"changeSet"), aname="_changeSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MissingProperty",lazy=True)(pname=(ns,"missingSet"), aname="_missingSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ObjectUpdate_Def.__bases__: + bases = list(ns0.ObjectUpdate_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ObjectUpdate_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfObjectUpdate_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfObjectUpdate") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfObjectUpdate_Def.schema + TClist = [GTD("urn:vim25","ObjectUpdate",lazy=True)(pname=(ns,"ObjectUpdate"), aname="_ObjectUpdate", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ObjectUpdate = [] + return + Holder.__name__ = "ArrayOfObjectUpdate_Holder" + self.pyclass = Holder + + class PropertyChangeOp_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PropertyChangeOp") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class PropertyChange_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PropertyChange") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PropertyChange_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyChangeOp",lazy=True)(pname=(ns,"op"), aname="_op", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"val"), aname="_val", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PropertyChange_Def.__bases__: + bases = list(ns0.PropertyChange_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PropertyChange_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPropertyChange_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPropertyChange") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPropertyChange_Def.schema + TClist = [GTD("urn:vim25","PropertyChange",lazy=True)(pname=(ns,"PropertyChange"), aname="_PropertyChange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PropertyChange = [] + return + Holder.__name__ = "ArrayOfPropertyChange_Holder" + self.pyclass = Holder + + class MissingProperty_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingProperty") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingProperty_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.MissingProperty_Def.__bases__: + bases = list(ns0.MissingProperty_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.MissingProperty_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfMissingProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfMissingProperty") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfMissingProperty_Def.schema + TClist = [GTD("urn:vim25","MissingProperty",lazy=True)(pname=(ns,"MissingProperty"), aname="_MissingProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._MissingProperty = [] + return + Holder.__name__ = "ArrayOfMissingProperty_Holder" + self.pyclass = Holder + + class MissingObject_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingObject") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingObject_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.MissingObject_Def.__bases__: + bases = list(ns0.MissingObject_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.MissingObject_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfMissingObject_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfMissingObject") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfMissingObject_Def.schema + TClist = [GTD("urn:vim25","MissingObject",lazy=True)(pname=(ns,"MissingObject"), aname="_MissingObject", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._MissingObject = [] + return + Holder.__name__ = "ArrayOfMissingObject_Holder" + self.pyclass = Holder + + class CreateFilterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateFilterRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateFilterRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyFilterSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"partialUpdates"), aname="_partialUpdates", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + self._partialUpdates = None + return + Holder.__name__ = "CreateFilterRequestType_Holder" + self.pyclass = Holder + + class RetrievePropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrievePropertiesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrievePropertiesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyFilterSpec",lazy=True)(pname=(ns,"specSet"), aname="_specSet", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._specSet = [] + return + Holder.__name__ = "RetrievePropertiesRequestType_Holder" + self.pyclass = Holder + + class CheckForUpdatesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckForUpdatesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckForUpdatesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._version = None + return + Holder.__name__ = "CheckForUpdatesRequestType_Holder" + self.pyclass = Holder + + class WaitForUpdatesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "WaitForUpdatesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.WaitForUpdatesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._version = None + return + Holder.__name__ = "WaitForUpdatesRequestType_Holder" + self.pyclass = Holder + + class CancelWaitForUpdatesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CancelWaitForUpdatesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CancelWaitForUpdatesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "CancelWaitForUpdatesRequestType_Holder" + self.pyclass = Holder + + class LocalizedMethodFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LocalizedMethodFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LocalizedMethodFault_Def.schema + TClist = [GTD("urn:vim25","MethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localizedMessage"), aname="_localizedMessage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LocalizedMethodFault_Def.__bases__: + bases = list(ns0.LocalizedMethodFault_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LocalizedMethodFault_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MethodFault_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MethodFault") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MethodFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"dynamicType"), aname="_dynamicType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"dynamicProperty"), aname="_dynamicProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"faultCause"), aname="_faultCause", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"faultMessage"), aname="_faultMessage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._dynamicType = None + self._dynamicProperty = [] + self._faultCause = None + self._faultMessage = [] + return + Holder.__name__ = "MethodFault_Holder" + self.pyclass = Holder + + class ArrayOfMethodFault_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfMethodFault") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfMethodFault_Def.schema + TClist = [GTD("urn:vim25","MethodFault",lazy=True)(pname=(ns,"MethodFault"), aname="_MethodFault", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._MethodFault = [] + return + Holder.__name__ = "ArrayOfMethodFault_Holder" + self.pyclass = Holder + + class RuntimeFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RuntimeFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RuntimeFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MethodFault_Def not in ns0.RuntimeFault_Def.__bases__: + bases = list(ns0.RuntimeFault_Def.__bases__) + bases.insert(0, ns0.MethodFault_Def) + ns0.RuntimeFault_Def.__bases__ = tuple(bases) + + ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AboutInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AboutInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AboutInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"build"), aname="_build", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localeVersion"), aname="_localeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localeBuild"), aname="_localeBuild", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"osType"), aname="_osType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productLineId"), aname="_productLineId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"apiType"), aname="_apiType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"apiVersion"), aname="_apiVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseProductName"), aname="_licenseProductName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseProductVersion"), aname="_licenseProductVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AboutInfo_Def.__bases__: + bases = list(ns0.AboutInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AboutInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AuthorizationDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AuthorizationDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AuthorizationDescription_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"privilege"), aname="_privilege", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"privilegeGroup"), aname="_privilegeGroup", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AuthorizationDescription_Def.__bases__: + bases = list(ns0.AuthorizationDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AuthorizationDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class Permission_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Permission") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Permission_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"propagate"), aname="_propagate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.Permission_Def.__bases__: + bases = list(ns0.Permission_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.Permission_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPermission_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPermission") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPermission_Def.schema + TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"Permission"), aname="_Permission", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._Permission = [] + return + Holder.__name__ = "ArrayOfPermission_Holder" + self.pyclass = Holder + + class AuthorizationRole_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AuthorizationRole") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AuthorizationRole_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"system"), aname="_system", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privilege"), aname="_privilege", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AuthorizationRole_Def.__bases__: + bases = list(ns0.AuthorizationRole_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AuthorizationRole_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfAuthorizationRole_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAuthorizationRole") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAuthorizationRole_Def.schema + TClist = [GTD("urn:vim25","AuthorizationRole",lazy=True)(pname=(ns,"AuthorizationRole"), aname="_AuthorizationRole", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._AuthorizationRole = [] + return + Holder.__name__ = "ArrayOfAuthorizationRole_Holder" + self.pyclass = Holder + + class AuthorizationPrivilege_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AuthorizationPrivilege") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AuthorizationPrivilege_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"privId"), aname="_privId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"onParent"), aname="_onParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privGroupName"), aname="_privGroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AuthorizationPrivilege_Def.__bases__: + bases = list(ns0.AuthorizationPrivilege_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AuthorizationPrivilege_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfAuthorizationPrivilege_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAuthorizationPrivilege") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAuthorizationPrivilege_Def.schema + TClist = [GTD("urn:vim25","AuthorizationPrivilege",lazy=True)(pname=(ns,"AuthorizationPrivilege"), aname="_AuthorizationPrivilege", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._AuthorizationPrivilege = [] + return + Holder.__name__ = "ArrayOfAuthorizationPrivilege_Holder" + self.pyclass = Holder + + class AddAuthorizationRoleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddAuthorizationRoleRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddAuthorizationRoleRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privIds"), aname="_privIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._privIds = [] + return + Holder.__name__ = "AddAuthorizationRoleRequestType_Holder" + self.pyclass = Holder + + class RemoveAuthorizationRoleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveAuthorizationRoleRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveAuthorizationRoleRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"failIfUsed"), aname="_failIfUsed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._roleId = None + self._failIfUsed = None + return + Holder.__name__ = "RemoveAuthorizationRoleRequestType_Holder" + self.pyclass = Holder + + class UpdateAuthorizationRoleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateAuthorizationRoleRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateAuthorizationRoleRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privIds"), aname="_privIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._roleId = None + self._newName = None + self._privIds = [] + return + Holder.__name__ = "UpdateAuthorizationRoleRequestType_Holder" + self.pyclass = Holder + + class MergePermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MergePermissionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MergePermissionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"srcRoleId"), aname="_srcRoleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dstRoleId"), aname="_dstRoleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._srcRoleId = None + self._dstRoleId = None + return + Holder.__name__ = "MergePermissionsRequestType_Holder" + self.pyclass = Holder + + class RetrieveRolePermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveRolePermissionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveRolePermissionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._roleId = None + return + Holder.__name__ = "RetrieveRolePermissionsRequestType_Holder" + self.pyclass = Holder + + class RetrieveEntityPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveEntityPermissionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveEntityPermissionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inherited"), aname="_inherited", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._inherited = None + return + Holder.__name__ = "RetrieveEntityPermissionsRequestType_Holder" + self.pyclass = Holder + + class RetrieveAllPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveAllPermissionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveAllPermissionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RetrieveAllPermissionsRequestType_Holder" + self.pyclass = Holder + + class SetEntityPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetEntityPermissionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetEntityPermissionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"permission"), aname="_permission", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._permission = [] + return + Holder.__name__ = "SetEntityPermissionsRequestType_Holder" + self.pyclass = Holder + + class ResetEntityPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetEntityPermissionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetEntityPermissionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"permission"), aname="_permission", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._permission = [] + return + Holder.__name__ = "ResetEntityPermissionsRequestType_Holder" + self.pyclass = Holder + + class RemoveEntityPermissionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveEntityPermissionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveEntityPermissionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"isGroup"), aname="_isGroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._user = None + self._isGroup = None + return + Holder.__name__ = "RemoveEntityPermissionRequestType_Holder" + self.pyclass = Holder + + class BoolPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "BoolPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.BoolPolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.BoolPolicy_Def.__bases__: + bases = list(ns0.BoolPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.BoolPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class Capability_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Capability") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Capability_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"provisioningSupported"), aname="_provisioningSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multiHostSupported"), aname="_multiHostSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"userShellAccessSupported"), aname="_userShellAccessSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EVCMode",lazy=True)(pname=(ns,"supportedEVCMode"), aname="_supportedEVCMode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.Capability_Def.__bases__: + bases = list(ns0.Capability_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.Capability_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterComputeResourceSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterComputeResourceSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterComputeResourceSummary_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"currentFailoverLevel"), aname="_currentFailoverLevel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasAdmissionControlInfo",lazy=True)(pname=(ns,"admissionControlInfo"), aname="_admissionControlInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVmotions"), aname="_numVmotions", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"targetBalance"), aname="_targetBalance", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"currentBalance"), aname="_currentBalance", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ComputeResourceSummary_Def not in ns0.ClusterComputeResourceSummary_Def.__bases__: + bases = list(ns0.ClusterComputeResourceSummary_Def.__bases__) + bases.insert(0, ns0.ComputeResourceSummary_Def) + ns0.ClusterComputeResourceSummary_Def.__bases__ = tuple(bases) + + ns0.ComputeResourceSummary_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReconfigureClusterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureClusterRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureClusterRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"modify"), aname="_modify", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + self._modify = None + return + Holder.__name__ = "ReconfigureClusterRequestType_Holder" + self.pyclass = Holder + + class ApplyRecommendationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ApplyRecommendationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ApplyRecommendationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._key = None + return + Holder.__name__ = "ApplyRecommendationRequestType_Holder" + self.pyclass = Holder + + class RecommendHostsForVmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RecommendHostsForVmRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RecommendHostsForVmRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + self._pool = None + return + Holder.__name__ = "RecommendHostsForVmRequestType_Holder" + self.pyclass = Holder + + class AddHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"asConnected"), aname="_asConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + self._asConnected = None + self._resourcePool = None + self._license = None + return + Holder.__name__ = "AddHostRequestType_Holder" + self.pyclass = Holder + + class MoveIntoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MoveIntoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MoveIntoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = [] + return + Holder.__name__ = "MoveIntoRequestType_Holder" + self.pyclass = Holder + + class MoveHostIntoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MoveHostIntoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MoveHostIntoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._resourcePool = None + return + Holder.__name__ = "MoveHostIntoRequestType_Holder" + self.pyclass = Holder + + class RefreshRecommendationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshRecommendationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshRecommendationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshRecommendationRequestType_Holder" + self.pyclass = Holder + + class RetrieveDasAdvancedRuntimeInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveDasAdvancedRuntimeInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RetrieveDasAdvancedRuntimeInfoRequestType_Holder" + self.pyclass = Holder + + class ComputeResourceSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComputeResourceSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComputeResourceSummary_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"totalCpu"), aname="_totalCpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"totalMemory"), aname="_totalMemory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuThreads"), aname="_numCpuThreads", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"effectiveCpu"), aname="_effectiveCpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"effectiveMemory"), aname="_effectiveMemory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numHosts"), aname="_numHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numEffectiveHosts"), aname="_numEffectiveHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ComputeResourceSummary_Def.__bases__: + bases = list(ns0.ComputeResourceSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ComputeResourceSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ComputeResourceConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComputeResourceConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComputeResourceConfigInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vmSwapPlacement"), aname="_vmSwapPlacement", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ComputeResourceConfigInfo_Def.__bases__: + bases = list(ns0.ComputeResourceConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ComputeResourceConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ComputeResourceConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComputeResourceConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComputeResourceConfigSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vmSwapPlacement"), aname="_vmSwapPlacement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ComputeResourceConfigSpec_Def.__bases__: + bases = list(ns0.ComputeResourceConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ComputeResourceConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReconfigureComputeResourceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureComputeResourceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureComputeResourceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComputeResourceConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"modify"), aname="_modify", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + self._modify = None + return + Holder.__name__ = "ReconfigureComputeResourceRequestType_Holder" + self.pyclass = Holder + + class ConfigSpecOperation_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ConfigSpecOperation") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class CustomFieldDef_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldDef") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldDef_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"managedObjectType"), aname="_managedObjectType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldDefPrivileges"), aname="_fieldDefPrivileges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldInstancePrivileges"), aname="_fieldInstancePrivileges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomFieldDef_Def.__bases__: + bases = list(ns0.CustomFieldDef_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomFieldDef_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfCustomFieldDef_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfCustomFieldDef") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfCustomFieldDef_Def.schema + TClist = [GTD("urn:vim25","CustomFieldDef",lazy=True)(pname=(ns,"CustomFieldDef"), aname="_CustomFieldDef", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._CustomFieldDef = [] + return + Holder.__name__ = "ArrayOfCustomFieldDef_Holder" + self.pyclass = Holder + + class CustomFieldValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldValue_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomFieldValue_Def.__bases__: + bases = list(ns0.CustomFieldValue_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomFieldValue_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfCustomFieldValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfCustomFieldValue") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfCustomFieldValue_Def.schema + TClist = [GTD("urn:vim25","CustomFieldValue",lazy=True)(pname=(ns,"CustomFieldValue"), aname="_CustomFieldValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._CustomFieldValue = [] + return + Holder.__name__ = "ArrayOfCustomFieldValue_Holder" + self.pyclass = Holder + + class CustomFieldStringValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldStringValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldStringValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomFieldValue_Def not in ns0.CustomFieldStringValue_Def.__bases__: + bases = list(ns0.CustomFieldStringValue_Def.__bases__) + bases.insert(0, ns0.CustomFieldValue_Def) + ns0.CustomFieldStringValue_Def.__bases__ = tuple(bases) + + ns0.CustomFieldValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AddCustomFieldDefRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddCustomFieldDefRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddCustomFieldDefRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"moType"), aname="_moType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldDefPolicy"), aname="_fieldDefPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldPolicy"), aname="_fieldPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._moType = None + self._fieldDefPolicy = None + self._fieldPolicy = None + return + Holder.__name__ = "AddCustomFieldDefRequestType_Holder" + self.pyclass = Holder + + class RemoveCustomFieldDefRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveCustomFieldDefRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveCustomFieldDefRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._key = None + return + Holder.__name__ = "RemoveCustomFieldDefRequestType_Holder" + self.pyclass = Holder + + class RenameCustomFieldDefRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RenameCustomFieldDefRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RenameCustomFieldDefRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._key = None + self._name = None + return + Holder.__name__ = "RenameCustomFieldDefRequestType_Holder" + self.pyclass = Holder + + class SetFieldRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetFieldRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetFieldRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._key = None + self._value = None + return + Holder.__name__ = "SetFieldRequestType_Holder" + self.pyclass = Holder + + class DoesCustomizationSpecExistRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DoesCustomizationSpecExistRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DoesCustomizationSpecExistRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + return + Holder.__name__ = "DoesCustomizationSpecExistRequestType_Holder" + self.pyclass = Holder + + class GetCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "GetCustomizationSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.GetCustomizationSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + return + Holder.__name__ = "GetCustomizationSpecRequestType_Holder" + self.pyclass = Holder + + class CreateCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateCustomizationSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateCustomizationSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"item"), aname="_item", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._item = None + return + Holder.__name__ = "CreateCustomizationSpecRequestType_Holder" + self.pyclass = Holder + + class OverwriteCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "OverwriteCustomizationSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.OverwriteCustomizationSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"item"), aname="_item", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._item = None + return + Holder.__name__ = "OverwriteCustomizationSpecRequestType_Holder" + self.pyclass = Holder + + class DeleteCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DeleteCustomizationSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DeleteCustomizationSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + return + Holder.__name__ = "DeleteCustomizationSpecRequestType_Holder" + self.pyclass = Holder + + class DuplicateCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DuplicateCustomizationSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DuplicateCustomizationSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._newName = None + return + Holder.__name__ = "DuplicateCustomizationSpecRequestType_Holder" + self.pyclass = Holder + + class RenameCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RenameCustomizationSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RenameCustomizationSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._newName = None + return + Holder.__name__ = "RenameCustomizationSpecRequestType_Holder" + self.pyclass = Holder + + class CustomizationSpecItemToXmlRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CustomizationSpecItemToXmlRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CustomizationSpecItemToXmlRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"item"), aname="_item", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._item = None + return + Holder.__name__ = "CustomizationSpecItemToXmlRequestType_Holder" + self.pyclass = Holder + + class XmlToCustomizationSpecItemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "XmlToCustomizationSpecItemRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.XmlToCustomizationSpecItemRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"specItemXml"), aname="_specItemXml", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._specItemXml = None + return + Holder.__name__ = "XmlToCustomizationSpecItemRequestType_Holder" + self.pyclass = Holder + + class CheckCustomizationResourcesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckCustomizationResourcesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckCustomizationResourcesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestOs"), aname="_guestOs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._guestOs = None + return + Holder.__name__ = "CheckCustomizationResourcesRequestType_Holder" + self.pyclass = Holder + + class CustomizationSpecInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationSpecInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationSpecInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastUpdateTime"), aname="_lastUpdateTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationSpecInfo_Def.__bases__: + bases = list(ns0.CustomizationSpecInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationSpecInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfCustomizationSpecInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfCustomizationSpecInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfCustomizationSpecInfo_Def.schema + TClist = [GTD("urn:vim25","CustomizationSpecInfo",lazy=True)(pname=(ns,"CustomizationSpecInfo"), aname="_CustomizationSpecInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._CustomizationSpecInfo = [] + return + Holder.__name__ = "ArrayOfCustomizationSpecInfo_Holder" + self.pyclass = Holder + + class CustomizationSpecItem_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationSpecItem") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationSpecItem_Def.schema + TClist = [GTD("urn:vim25","CustomizationSpecInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationSpecItem_Def.__bases__: + bases = list(ns0.CustomizationSpecItem_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationSpecItem_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class QueryConnectionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryConnectionInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryConnectionInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"username"), aname="_username", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._hostname = None + self._port = None + self._username = None + self._password = None + self._sslThumbprint = None + return + Holder.__name__ = "QueryConnectionInfoRequestType_Holder" + self.pyclass = Holder + + class PowerOnMultiVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PowerOnMultiVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PowerOnMultiVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = [] + return + Holder.__name__ = "PowerOnMultiVMRequestType_Holder" + self.pyclass = Holder + + class DatastoreAccessible_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DatastoreAccessible") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DatastoreSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreSummary_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"freeSpace"), aname="_freeSpace", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"uncommitted"), aname="_uncommitted", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"accessible"), aname="_accessible", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multipleHostAccess"), aname="_multipleHostAccess", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatastoreSummary_Def.__bases__: + bases = list(ns0.DatastoreSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatastoreSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"freeSpace"), aname="_freeSpace", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxFileSize"), aname="_maxFileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatastoreInfo_Def.__bases__: + bases = list(ns0.DatastoreInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatastoreInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreCapability_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreCapability") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreCapability_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"directoryHierarchySupported"), aname="_directoryHierarchySupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rawDiskMappingsSupported"), aname="_rawDiskMappingsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"perFileThinProvisioningSupported"), aname="_perFileThinProvisioningSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatastoreCapability_Def.__bases__: + bases = list(ns0.DatastoreCapability_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatastoreCapability_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreHostMount_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreHostMount") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreHostMount_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMountInfo",lazy=True)(pname=(ns,"mountInfo"), aname="_mountInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatastoreHostMount_Def.__bases__: + bases = list(ns0.DatastoreHostMount_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatastoreHostMount_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDatastoreHostMount_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDatastoreHostMount") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDatastoreHostMount_Def.schema + TClist = [GTD("urn:vim25","DatastoreHostMount",lazy=True)(pname=(ns,"DatastoreHostMount"), aname="_DatastoreHostMount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DatastoreHostMount = [] + return + Holder.__name__ = "ArrayOfDatastoreHostMount_Holder" + self.pyclass = Holder + + class RefreshDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshDatastoreRequestType_Holder" + self.pyclass = Holder + + class RefreshDatastoreStorageInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshDatastoreStorageInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshDatastoreStorageInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshDatastoreStorageInfoRequestType_Holder" + self.pyclass = Holder + + class RenameDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RenameDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RenameDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._newName = None + return + Holder.__name__ = "RenameDatastoreRequestType_Holder" + self.pyclass = Holder + + class DestroyDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DestroyDatastoreRequestType_Holder" + self.pyclass = Holder + + class Description_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Description") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Description_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"summary"), aname="_summary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.Description_Def.__bases__: + bases = list(ns0.Description_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.Description_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DiagnosticManagerLogCreator_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DiagnosticManagerLogCreator") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DiagnosticManagerLogFormat_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DiagnosticManagerLogFormat") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DiagnosticManagerLogDescriptor_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DiagnosticManagerLogDescriptor") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DiagnosticManagerLogDescriptor_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fileName"), aname="_fileName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"creator"), aname="_creator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"format"), aname="_format", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mimeType"), aname="_mimeType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DiagnosticManagerLogDescriptor_Def.__bases__: + bases = list(ns0.DiagnosticManagerLogDescriptor_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DiagnosticManagerLogDescriptor_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDiagnosticManagerLogDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDiagnosticManagerLogDescriptor") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDiagnosticManagerLogDescriptor_Def.schema + TClist = [GTD("urn:vim25","DiagnosticManagerLogDescriptor",lazy=True)(pname=(ns,"DiagnosticManagerLogDescriptor"), aname="_DiagnosticManagerLogDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DiagnosticManagerLogDescriptor = [] + return + Holder.__name__ = "ArrayOfDiagnosticManagerLogDescriptor_Holder" + self.pyclass = Holder + + class DiagnosticManagerLogHeader_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DiagnosticManagerLogHeader") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DiagnosticManagerLogHeader_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineStart"), aname="_lineStart", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lineEnd"), aname="_lineEnd", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lineText"), aname="_lineText", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DiagnosticManagerLogHeader_Def.__bases__: + bases = list(ns0.DiagnosticManagerLogHeader_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DiagnosticManagerLogHeader_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DiagnosticManagerBundleInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DiagnosticManagerBundleInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DiagnosticManagerBundleInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"system"), aname="_system", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DiagnosticManagerBundleInfo_Def.__bases__: + bases = list(ns0.DiagnosticManagerBundleInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DiagnosticManagerBundleInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDiagnosticManagerBundleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDiagnosticManagerBundleInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDiagnosticManagerBundleInfo_Def.schema + TClist = [GTD("urn:vim25","DiagnosticManagerBundleInfo",lazy=True)(pname=(ns,"DiagnosticManagerBundleInfo"), aname="_DiagnosticManagerBundleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DiagnosticManagerBundleInfo = [] + return + Holder.__name__ = "ArrayOfDiagnosticManagerBundleInfo_Holder" + self.pyclass = Holder + + class QueryDescriptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryDescriptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryDescriptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "QueryDescriptionsRequestType_Holder" + self.pyclass = Holder + + class BrowseDiagnosticLogRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "BrowseDiagnosticLogRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.BrowseDiagnosticLogRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"start"), aname="_start", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lines"), aname="_lines", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._key = None + self._start = None + self._lines = None + return + Holder.__name__ = "BrowseDiagnosticLogRequestType_Holder" + self.pyclass = Holder + + class GenerateLogBundlesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "GenerateLogBundlesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.GenerateLogBundlesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"includeDefault"), aname="_includeDefault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._includeDefault = None + self._host = [] + return + Holder.__name__ = "GenerateLogBundlesRequestType_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchProductSpecOperationType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchProductSpecOperationType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DVSContactInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSContactInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSContactInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contact"), aname="_contact", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSContactInfo_Def.__bases__: + bases = list(ns0.DVSContactInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSContactInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSCapability_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSCapability") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSCapability_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"dvsOperationSupported"), aname="_dvsOperationSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dvPortGroupOperationSupported"), aname="_dvPortGroupOperationSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dvPortOperationSupported"), aname="_dvPortOperationSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostProductSpec",lazy=True)(pname=(ns,"compatibleHostComponentProductInfo"), aname="_compatibleHostComponentProductInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSCapability_Def.__bases__: + bases = list(ns0.DVSCapability_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSCapability_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSSummary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hostMember"), aname="_hostMember", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSContactInfo",lazy=True)(pname=(ns,"contact"), aname="_contact", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSSummary_Def.__bases__: + bases = list(ns0.DVSSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSPolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"autoPreInstallAllowed"), aname="_autoPreInstallAllowed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoUpgradeAllowed"), aname="_autoUpgradeAllowed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"partialUpgradeAllowed"), aname="_partialUpgradeAllowed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSPolicy_Def.__bases__: + bases = list(ns0.DVSPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSUplinkPortPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSUplinkPortPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSUplinkPortPolicy_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSUplinkPortPolicy_Def.__bases__: + bases = list(ns0.DVSUplinkPortPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSUplinkPortPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSNameArrayUplinkPortPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSNameArrayUplinkPortPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSNameArrayUplinkPortPolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"uplinkPortName"), aname="_uplinkPortName", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVSUplinkPortPolicy_Def not in ns0.DVSNameArrayUplinkPortPolicy_Def.__bases__: + bases = list(ns0.DVSNameArrayUplinkPortPolicy_Def.__bases__) + bases.insert(0, ns0.DVSUplinkPortPolicy_Def) + ns0.DVSNameArrayUplinkPortPolicy_Def.__bases__ = tuple(bases) + + ns0.DVSUplinkPortPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSConfigSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numStandalonePorts"), aname="_numStandalonePorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxPorts"), aname="_maxPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSUplinkPortPolicy",lazy=True)(pname=(ns,"uplinkPortPolicy"), aname="_uplinkPortPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"uplinkPortgroup"), aname="_uplinkPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMemberConfigSpec",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSContactInfo",lazy=True)(pname=(ns,"contact"), aname="_contact", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSConfigSpec_Def.__bases__: + bases = list(ns0.DVSConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSCreateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSCreateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSCreateSpec_Def.schema + TClist = [GTD("urn:vim25","DVSConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSCreateSpec_Def.__bases__: + bases = list(ns0.DVSCreateSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSCreateSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSConfigInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numStandalonePorts"), aname="_numStandalonePorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxPorts"), aname="_maxPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSUplinkPortPolicy",lazy=True)(pname=(ns,"uplinkPortPolicy"), aname="_uplinkPortPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"uplinkPortgroup"), aname="_uplinkPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMember",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"targetInfo"), aname="_targetInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSContactInfo",lazy=True)(pname=(ns,"contact"), aname="_contact", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"createTime"), aname="_createTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSConfigInfo_Def.__bases__: + bases = list(ns0.DVSConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSFetchKeyOfPortsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSFetchKeyOfPortsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSFetchKeyOfPortsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortCriteria",lazy=True)(pname=(ns,"criteria"), aname="_criteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._criteria = None + return + Holder.__name__ = "DVSFetchKeyOfPortsRequestType_Holder" + self.pyclass = Holder + + class DVSFetchPortsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSFetchPortsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSFetchPortsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortCriteria",lazy=True)(pname=(ns,"criteria"), aname="_criteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._criteria = None + return + Holder.__name__ = "DVSFetchPortsRequestType_Holder" + self.pyclass = Holder + + class DVSQueryUsedVlanIdRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSQueryUsedVlanIdRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSQueryUsedVlanIdRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DVSQueryUsedVlanIdRequestType_Holder" + self.pyclass = Holder + + class DVSReconfigureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSReconfigureRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSReconfigureRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "DVSReconfigureRequestType_Holder" + self.pyclass = Holder + + class DVSPerformProductSpecOperationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSPerformProductSpecOperationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSPerformProductSpecOperationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productSpec"), aname="_productSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._operation = None + self._productSpec = None + return + Holder.__name__ = "DVSPerformProductSpecOperationRequestType_Holder" + self.pyclass = Holder + + class DVSMergeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSMergeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSMergeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dvs = None + return + Holder.__name__ = "DVSMergeRequestType_Holder" + self.pyclass = Holder + + class DVSAddPortgroupsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSAddPortgroupsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSAddPortgroupsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = [] + return + Holder.__name__ = "DVSAddPortgroupsRequestType_Holder" + self.pyclass = Holder + + class DVSMovePortRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSMovePortRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSMovePortRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destinationPortgroupKey"), aname="_destinationPortgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._portKey = [] + self._destinationPortgroupKey = None + return + Holder.__name__ = "DVSMovePortRequestType_Holder" + self.pyclass = Holder + + class DVSUpdateCapabilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSUpdateCapabilityRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSUpdateCapabilityRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._capability = None + return + Holder.__name__ = "DVSUpdateCapabilityRequestType_Holder" + self.pyclass = Holder + + class ReconfigurePortRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigurePortRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigurePortRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortConfigSpec",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._port = [] + return + Holder.__name__ = "ReconfigurePortRequestType_Holder" + self.pyclass = Holder + + class DVSRefreshPortStateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSRefreshPortStateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSRefreshPortStateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKeys"), aname="_portKeys", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._portKeys = [] + return + Holder.__name__ = "DVSRefreshPortStateRequestType_Holder" + self.pyclass = Holder + + class DVSRectifyHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSRectifyHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSRectifyHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hosts"), aname="_hosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._hosts = [] + return + Holder.__name__ = "DVSRectifyHostRequestType_Holder" + self.pyclass = Holder + + class EVCMode_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCMode") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCMode_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vendorTier"), aname="_vendorTier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ElementDescription_Def not in ns0.EVCMode_Def.__bases__: + bases = list(ns0.EVCMode_Def.__bases__) + bases.insert(0, ns0.ElementDescription_Def) + ns0.EVCMode_Def.__bases__ = tuple(bases) + + ns0.ElementDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfEVCMode_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfEVCMode") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfEVCMode_Def.schema + TClist = [GTD("urn:vim25","EVCMode",lazy=True)(pname=(ns,"EVCMode"), aname="_EVCMode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._EVCMode = [] + return + Holder.__name__ = "ArrayOfEVCMode_Holder" + self.pyclass = Holder + + class ElementDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ElementDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ElementDescription_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Description_Def not in ns0.ElementDescription_Def.__bases__: + bases = list(ns0.ElementDescription_Def.__bases__) + bases.insert(0, ns0.Description_Def) + ns0.ElementDescription_Def.__bases__ = tuple(bases) + + ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfElementDescription_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfElementDescription") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfElementDescription_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"ElementDescription"), aname="_ElementDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ElementDescription = [] + return + Holder.__name__ = "ArrayOfElementDescription_Holder" + self.pyclass = Holder + + class EnumDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EnumDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EnumDescription_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"tags"), aname="_tags", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EnumDescription_Def.__bases__: + bases = list(ns0.EnumDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EnumDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfEnumDescription_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfEnumDescription") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfEnumDescription_Def.schema + TClist = [GTD("urn:vim25","EnumDescription",lazy=True)(pname=(ns,"EnumDescription"), aname="_EnumDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._EnumDescription = [] + return + Holder.__name__ = "ArrayOfEnumDescription_Holder" + self.pyclass = Holder + + class QueryConfigOptionDescriptorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryConfigOptionDescriptorRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryConfigOptionDescriptorRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryConfigOptionDescriptorRequestType_Holder" + self.pyclass = Holder + + class QueryConfigOptionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryConfigOptionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryConfigOptionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._key = None + self._host = None + return + Holder.__name__ = "QueryConfigOptionRequestType_Holder" + self.pyclass = Holder + + class QueryConfigTargetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryConfigTargetRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryConfigTargetRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "QueryConfigTargetRequestType_Holder" + self.pyclass = Holder + + class QueryTargetCapabilitiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryTargetCapabilitiesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryTargetCapabilitiesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "QueryTargetCapabilitiesRequestType_Holder" + self.pyclass = Holder + + class ExtendedDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtendedDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtendedDescription_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"messageCatalogKeyPrefix"), aname="_messageCatalogKeyPrefix", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"messageArg"), aname="_messageArg", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Description_Def not in ns0.ExtendedDescription_Def.__bases__: + bases = list(ns0.ExtendedDescription_Def.__bases__) + bases.insert(0, ns0.Description_Def) + ns0.ExtendedDescription_Def.__bases__ = tuple(bases) + + ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExtendedElementDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtendedElementDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtendedElementDescription_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"messageCatalogKeyPrefix"), aname="_messageCatalogKeyPrefix", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"messageArg"), aname="_messageArg", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ElementDescription_Def not in ns0.ExtendedElementDescription_Def.__bases__: + bases = list(ns0.ExtendedElementDescription_Def.__bases__) + bases.insert(0, ns0.ElementDescription_Def) + ns0.ExtendedElementDescription_Def.__bases__ = tuple(bases) + + ns0.ElementDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class setCustomValueRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "setCustomValueRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.setCustomValueRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._key = None + self._value = None + return + Holder.__name__ = "setCustomValueRequestType_Holder" + self.pyclass = Holder + + class ExtensionServerInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionServerInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionServerInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"company"), aname="_company", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adminEmail"), aname="_adminEmail", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionServerInfo_Def.__bases__: + bases = list(ns0.ExtensionServerInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionServerInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtensionServerInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtensionServerInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtensionServerInfo_Def.schema + TClist = [GTD("urn:vim25","ExtensionServerInfo",lazy=True)(pname=(ns,"ExtensionServerInfo"), aname="_ExtensionServerInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtensionServerInfo = [] + return + Holder.__name__ = "ArrayOfExtensionServerInfo_Holder" + self.pyclass = Holder + + class ExtensionClientInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionClientInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionClientInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"company"), aname="_company", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionClientInfo_Def.__bases__: + bases = list(ns0.ExtensionClientInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionClientInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtensionClientInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtensionClientInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtensionClientInfo_Def.schema + TClist = [GTD("urn:vim25","ExtensionClientInfo",lazy=True)(pname=(ns,"ExtensionClientInfo"), aname="_ExtensionClientInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtensionClientInfo = [] + return + Holder.__name__ = "ArrayOfExtensionClientInfo_Holder" + self.pyclass = Holder + + class ExtensionTaskTypeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionTaskTypeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionTaskTypeInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"taskID"), aname="_taskID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionTaskTypeInfo_Def.__bases__: + bases = list(ns0.ExtensionTaskTypeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionTaskTypeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtensionTaskTypeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtensionTaskTypeInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtensionTaskTypeInfo_Def.schema + TClist = [GTD("urn:vim25","ExtensionTaskTypeInfo",lazy=True)(pname=(ns,"ExtensionTaskTypeInfo"), aname="_ExtensionTaskTypeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtensionTaskTypeInfo = [] + return + Holder.__name__ = "ArrayOfExtensionTaskTypeInfo_Holder" + self.pyclass = Holder + + class ExtensionEventTypeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionEventTypeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionEventTypeInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"eventID"), aname="_eventID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeSchema"), aname="_eventTypeSchema", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionEventTypeInfo_Def.__bases__: + bases = list(ns0.ExtensionEventTypeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionEventTypeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtensionEventTypeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtensionEventTypeInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtensionEventTypeInfo_Def.schema + TClist = [GTD("urn:vim25","ExtensionEventTypeInfo",lazy=True)(pname=(ns,"ExtensionEventTypeInfo"), aname="_ExtensionEventTypeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtensionEventTypeInfo = [] + return + Holder.__name__ = "ArrayOfExtensionEventTypeInfo_Holder" + self.pyclass = Holder + + class ExtensionFaultTypeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionFaultTypeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionFaultTypeInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"faultID"), aname="_faultID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionFaultTypeInfo_Def.__bases__: + bases = list(ns0.ExtensionFaultTypeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionFaultTypeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtensionFaultTypeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtensionFaultTypeInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtensionFaultTypeInfo_Def.schema + TClist = [GTD("urn:vim25","ExtensionFaultTypeInfo",lazy=True)(pname=(ns,"ExtensionFaultTypeInfo"), aname="_ExtensionFaultTypeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtensionFaultTypeInfo = [] + return + Holder.__name__ = "ArrayOfExtensionFaultTypeInfo_Holder" + self.pyclass = Holder + + class ExtensionPrivilegeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionPrivilegeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionPrivilegeInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"privID"), aname="_privID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privGroupName"), aname="_privGroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionPrivilegeInfo_Def.__bases__: + bases = list(ns0.ExtensionPrivilegeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionPrivilegeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtensionPrivilegeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtensionPrivilegeInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtensionPrivilegeInfo_Def.schema + TClist = [GTD("urn:vim25","ExtensionPrivilegeInfo",lazy=True)(pname=(ns,"ExtensionPrivilegeInfo"), aname="_ExtensionPrivilegeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtensionPrivilegeInfo = [] + return + Holder.__name__ = "ArrayOfExtensionPrivilegeInfo_Holder" + self.pyclass = Holder + + class ExtensionResourceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionResourceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionResourceInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"module"), aname="_module", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"data"), aname="_data", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionResourceInfo_Def.__bases__: + bases = list(ns0.ExtensionResourceInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionResourceInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtensionResourceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtensionResourceInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtensionResourceInfo_Def.schema + TClist = [GTD("urn:vim25","ExtensionResourceInfo",lazy=True)(pname=(ns,"ExtensionResourceInfo"), aname="_ExtensionResourceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtensionResourceInfo = [] + return + Holder.__name__ = "ArrayOfExtensionResourceInfo_Holder" + self.pyclass = Holder + + class ExtensionHealthInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtensionHealthInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtensionHealthInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtensionHealthInfo_Def.__bases__: + bases = list(ns0.ExtensionHealthInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtensionHealthInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class Extension_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Extension") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Extension_Def.schema + TClist = [GTD("urn:vim25","Description",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"company"), aname="_company", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subjectName"), aname="_subjectName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionServerInfo",lazy=True)(pname=(ns,"server"), aname="_server", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionClientInfo",lazy=True)(pname=(ns,"client"), aname="_client", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionTaskTypeInfo",lazy=True)(pname=(ns,"taskList"), aname="_taskList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionEventTypeInfo",lazy=True)(pname=(ns,"eventList"), aname="_eventList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionFaultTypeInfo",lazy=True)(pname=(ns,"faultList"), aname="_faultList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionPrivilegeInfo",lazy=True)(pname=(ns,"privilegeList"), aname="_privilegeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionResourceInfo",lazy=True)(pname=(ns,"resourceList"), aname="_resourceList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastHeartbeatTime"), aname="_lastHeartbeatTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionHealthInfo",lazy=True)(pname=(ns,"healthInfo"), aname="_healthInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.Extension_Def.__bases__: + bases = list(ns0.Extension_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.Extension_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtension_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtension") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtension_Def.schema + TClist = [GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"Extension"), aname="_Extension", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._Extension = [] + return + Holder.__name__ = "ArrayOfExtension_Holder" + self.pyclass = Holder + + class UnregisterExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UnregisterExtensionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UnregisterExtensionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._extensionKey = None + return + Holder.__name__ = "UnregisterExtensionRequestType_Holder" + self.pyclass = Holder + + class FindExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindExtensionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindExtensionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._extensionKey = None + return + Holder.__name__ = "FindExtensionRequestType_Holder" + self.pyclass = Holder + + class RegisterExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RegisterExtensionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RegisterExtensionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"extension"), aname="_extension", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._extension = None + return + Holder.__name__ = "RegisterExtensionRequestType_Holder" + self.pyclass = Holder + + class UpdateExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateExtensionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateExtensionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"extension"), aname="_extension", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._extension = None + return + Holder.__name__ = "UpdateExtensionRequestType_Holder" + self.pyclass = Holder + + class GetPublicKeyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "GetPublicKeyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.GetPublicKeyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "GetPublicKeyRequestType_Holder" + self.pyclass = Holder + + class SetPublicKeyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetPublicKeyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetPublicKeyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"publicKey"), aname="_publicKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._extensionKey = None + self._publicKey = None + return + Holder.__name__ = "SetPublicKeyRequestType_Holder" + self.pyclass = Holder + + class MoveDatastoreFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MoveDatastoreFileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MoveDatastoreFileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destinationName"), aname="_destinationName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destinationDatacenter"), aname="_destinationDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._sourceName = None + self._sourceDatacenter = None + self._destinationName = None + self._destinationDatacenter = None + self._force = None + return + Holder.__name__ = "MoveDatastoreFileRequestType_Holder" + self.pyclass = Holder + + class CopyDatastoreFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CopyDatastoreFileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CopyDatastoreFileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destinationName"), aname="_destinationName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destinationDatacenter"), aname="_destinationDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._sourceName = None + self._sourceDatacenter = None + self._destinationName = None + self._destinationDatacenter = None + self._force = None + return + Holder.__name__ = "CopyDatastoreFileRequestType_Holder" + self.pyclass = Holder + + class DeleteDatastoreFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DeleteDatastoreFileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DeleteDatastoreFileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "DeleteDatastoreFileRequestType_Holder" + self.pyclass = Holder + + class MakeDirectoryRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MakeDirectoryRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MakeDirectoryRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"createParentDirectories"), aname="_createParentDirectories", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + self._createParentDirectories = None + return + Holder.__name__ = "MakeDirectoryRequestType_Holder" + self.pyclass = Holder + + class ChangeOwnerRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ChangeOwnerRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ChangeOwnerRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"owner"), aname="_owner", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + self._owner = None + return + Holder.__name__ = "ChangeOwnerRequestType_Holder" + self.pyclass = Holder + + class CreateFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateFolderRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateFolderRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + return + Holder.__name__ = "CreateFolderRequestType_Holder" + self.pyclass = Holder + + class MoveIntoFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MoveIntoFolderRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MoveIntoFolderRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"list"), aname="_list", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._list = [] + return + Holder.__name__ = "MoveIntoFolderRequestType_Holder" + self.pyclass = Holder + + class CreateVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + self._pool = None + self._host = None + return + Holder.__name__ = "CreateVMRequestType_Holder" + self.pyclass = Holder + + class RegisterVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RegisterVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RegisterVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"asTemplate"), aname="_asTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._path = None + self._name = None + self._asTemplate = None + self._pool = None + self._host = None + return + Holder.__name__ = "RegisterVMRequestType_Holder" + self.pyclass = Holder + + class CreateClusterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateClusterRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateClusterRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._spec = None + return + Holder.__name__ = "CreateClusterRequestType_Holder" + self.pyclass = Holder + + class CreateClusterExRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateClusterExRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateClusterExRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterConfigSpecEx",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._spec = None + return + Holder.__name__ = "CreateClusterExRequestType_Holder" + self.pyclass = Holder + + class AddStandaloneHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddStandaloneHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddStandaloneHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComputeResourceConfigSpec",lazy=True)(pname=(ns,"compResSpec"), aname="_compResSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"addConnected"), aname="_addConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + self._compResSpec = None + self._addConnected = None + self._license = None + return + Holder.__name__ = "AddStandaloneHostRequestType_Holder" + self.pyclass = Holder + + class CreateDatacenterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateDatacenterRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateDatacenterRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + return + Holder.__name__ = "CreateDatacenterRequestType_Holder" + self.pyclass = Holder + + class UnregisterAndDestroyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UnregisterAndDestroyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UnregisterAndDestroyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "UnregisterAndDestroyRequestType_Holder" + self.pyclass = Holder + + class FolderCreateDVSRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FolderCreateDVSRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FolderCreateDVSRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "FolderCreateDVSRequestType_Holder" + self.pyclass = Holder + + class SetCollectorPageSizeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetCollectorPageSizeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetCollectorPageSizeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._maxCount = None + return + Holder.__name__ = "SetCollectorPageSizeRequestType_Holder" + self.pyclass = Holder + + class RewindCollectorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RewindCollectorRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RewindCollectorRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RewindCollectorRequestType_Holder" + self.pyclass = Holder + + class ResetCollectorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetCollectorRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetCollectorRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ResetCollectorRequestType_Holder" + self.pyclass = Holder + + class DestroyCollectorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyCollectorRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyCollectorRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DestroyCollectorRequestType_Holder" + self.pyclass = Holder + + class HostServiceTicket_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostServiceTicket") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostServiceTicket_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"service"), aname="_service", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"serviceVersion"), aname="_serviceVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostServiceTicket_Def.__bases__: + bases = list(ns0.HostServiceTicket_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostServiceTicket_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostSystemConnectionState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostSystemConnectionState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostSystemPowerState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostSystemPowerState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class QueryHostConnectionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryHostConnectionInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryHostConnectionInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryHostConnectionInfoRequestType_Holder" + self.pyclass = Holder + + class UpdateSystemResourcesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateSystemResourcesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateSystemResourcesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"resourceInfo"), aname="_resourceInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._resourceInfo = None + return + Holder.__name__ = "UpdateSystemResourcesRequestType_Holder" + self.pyclass = Holder + + class ReconnectHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconnectHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconnectHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectSpec",lazy=True)(pname=(ns,"cnxSpec"), aname="_cnxSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._cnxSpec = None + return + Holder.__name__ = "ReconnectHostRequestType_Holder" + self.pyclass = Holder + + class DisconnectHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DisconnectHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DisconnectHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DisconnectHostRequestType_Holder" + self.pyclass = Holder + + class EnterMaintenanceModeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EnterMaintenanceModeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.EnterMaintenanceModeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"evacuatePoweredOffVms"), aname="_evacuatePoweredOffVms", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._timeout = None + self._evacuatePoweredOffVms = None + return + Holder.__name__ = "EnterMaintenanceModeRequestType_Holder" + self.pyclass = Holder + + class ExitMaintenanceModeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExitMaintenanceModeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExitMaintenanceModeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._timeout = None + return + Holder.__name__ = "ExitMaintenanceModeRequestType_Holder" + self.pyclass = Holder + + class RebootHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RebootHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RebootHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._force = None + return + Holder.__name__ = "RebootHostRequestType_Holder" + self.pyclass = Holder + + class ShutdownHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ShutdownHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ShutdownHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._force = None + return + Holder.__name__ = "ShutdownHostRequestType_Holder" + self.pyclass = Holder + + class PowerDownHostToStandByRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PowerDownHostToStandByRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PowerDownHostToStandByRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeoutSec"), aname="_timeoutSec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"evacuatePoweredOffVms"), aname="_evacuatePoweredOffVms", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._timeoutSec = None + self._evacuatePoweredOffVms = None + return + Holder.__name__ = "PowerDownHostToStandByRequestType_Holder" + self.pyclass = Holder + + class PowerUpHostFromStandByRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PowerUpHostFromStandByRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PowerUpHostFromStandByRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeoutSec"), aname="_timeoutSec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._timeoutSec = None + return + Holder.__name__ = "PowerUpHostFromStandByRequestType_Holder" + self.pyclass = Holder + + class QueryMemoryOverheadRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryMemoryOverheadRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryMemoryOverheadRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memorySize"), aname="_memorySize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"videoRamSize"), aname="_videoRamSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVcpus"), aname="_numVcpus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._memorySize = None + self._videoRamSize = None + self._numVcpus = None + return + Holder.__name__ = "QueryMemoryOverheadRequestType_Holder" + self.pyclass = Holder + + class QueryMemoryOverheadExRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryMemoryOverheadExRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryMemoryOverheadExRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigInfo",lazy=True)(pname=(ns,"vmConfigInfo"), aname="_vmConfigInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vmConfigInfo = None + return + Holder.__name__ = "QueryMemoryOverheadExRequestType_Holder" + self.pyclass = Holder + + class ReconfigureHostForDASRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureHostForDASRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureHostForDASRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ReconfigureHostForDASRequestType_Holder" + self.pyclass = Holder + + class UpdateFlagsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateFlagsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateFlagsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFlagInfo",lazy=True)(pname=(ns,"flagInfo"), aname="_flagInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._flagInfo = None + return + Holder.__name__ = "UpdateFlagsRequestType_Holder" + self.pyclass = Holder + + class AcquireCimServicesTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AcquireCimServicesTicketRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AcquireCimServicesTicketRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "AcquireCimServicesTicketRequestType_Holder" + self.pyclass = Holder + + class UpdateIpmiRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateIpmiRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateIpmiRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpmiInfo",lazy=True)(pname=(ns,"ipmiInfo"), aname="_ipmiInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._ipmiInfo = None + return + Holder.__name__ = "UpdateIpmiRequestType_Holder" + self.pyclass = Holder + + class HttpNfcLeaseState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HttpNfcLeaseState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HttpNfcLeaseInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HttpNfcLeaseInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HttpNfcLeaseInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"lease"), aname="_lease", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HttpNfcLeaseDeviceUrl",lazy=True)(pname=(ns,"deviceUrl"), aname="_deviceUrl", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"totalDiskCapacityInKB"), aname="_totalDiskCapacityInKB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"leaseTimeout"), aname="_leaseTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HttpNfcLeaseInfo_Def.__bases__: + bases = list(ns0.HttpNfcLeaseInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HttpNfcLeaseInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HttpNfcLeaseDeviceUrl_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HttpNfcLeaseDeviceUrl") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HttpNfcLeaseDeviceUrl_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"importKey"), aname="_importKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HttpNfcLeaseDeviceUrl_Def.__bases__: + bases = list(ns0.HttpNfcLeaseDeviceUrl_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HttpNfcLeaseDeviceUrl_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHttpNfcLeaseDeviceUrl_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHttpNfcLeaseDeviceUrl") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHttpNfcLeaseDeviceUrl_Def.schema + TClist = [GTD("urn:vim25","HttpNfcLeaseDeviceUrl",lazy=True)(pname=(ns,"HttpNfcLeaseDeviceUrl"), aname="_HttpNfcLeaseDeviceUrl", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HttpNfcLeaseDeviceUrl = [] + return + Holder.__name__ = "ArrayOfHttpNfcLeaseDeviceUrl_Holder" + self.pyclass = Holder + + class HttpNfcLeaseCompleteRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HttpNfcLeaseCompleteRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HttpNfcLeaseCompleteRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "HttpNfcLeaseCompleteRequestType_Holder" + self.pyclass = Holder + + class HttpNfcLeaseAbortRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HttpNfcLeaseAbortRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HttpNfcLeaseAbortRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._fault = None + return + Holder.__name__ = "HttpNfcLeaseAbortRequestType_Holder" + self.pyclass = Holder + + class HttpNfcLeaseProgressRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HttpNfcLeaseProgressRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HttpNfcLeaseProgressRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"percent"), aname="_percent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._percent = None + return + Holder.__name__ = "HttpNfcLeaseProgressRequestType_Holder" + self.pyclass = Holder + + class ImportSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ImportSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ImportSpec_Def.schema + TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"entityConfig"), aname="_entityConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ImportSpec_Def.__bases__: + bases = list(ns0.ImportSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ImportSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfImportSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfImportSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfImportSpec_Def.schema + TClist = [GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"ImportSpec"), aname="_ImportSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ImportSpec = [] + return + Holder.__name__ = "ArrayOfImportSpec_Holder" + self.pyclass = Holder + + class InheritablePolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InheritablePolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InheritablePolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"inherited"), aname="_inherited", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.InheritablePolicy_Def.__bases__: + bases = list(ns0.InheritablePolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.InheritablePolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IntPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IntPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IntPolicy_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.IntPolicy_Def.__bases__: + bases = list(ns0.IntPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.IntPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class QueryIpPoolsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryIpPoolsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryIpPoolsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dc = None + return + Holder.__name__ = "QueryIpPoolsRequestType_Holder" + self.pyclass = Holder + + class CreateIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateIpPoolRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateIpPoolRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dc = None + self._pool = None + return + Holder.__name__ = "CreateIpPoolRequestType_Holder" + self.pyclass = Holder + + class UpdateIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateIpPoolRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateIpPoolRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dc = None + self._pool = None + return + Holder.__name__ = "UpdateIpPoolRequestType_Holder" + self.pyclass = Holder + + class DestroyIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyIpPoolRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyIpPoolRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dc = None + self._id = None + self._force = None + return + Holder.__name__ = "DestroyIpPoolRequestType_Holder" + self.pyclass = Holder + + class AssociateIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AssociateIpPoolRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AssociateIpPoolRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"net"), aname="_net", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"poolId"), aname="_poolId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dc = None + self._net = None + self._poolId = None + return + Holder.__name__ = "AssociateIpPoolRequestType_Holder" + self.pyclass = Holder + + class KeyValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "KeyValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.KeyValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.KeyValue_Def.__bases__: + bases = list(ns0.KeyValue_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.KeyValue_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfKeyValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfKeyValue") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfKeyValue_Def.schema + TClist = [GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"KeyValue"), aname="_KeyValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._KeyValue = [] + return + Holder.__name__ = "ArrayOfKeyValue_Holder" + self.pyclass = Holder + + class LicenseAssignmentManagerLicenseAssignment_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseAssignmentManagerLicenseAssignment") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseAssignmentManagerLicenseAssignment_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityDisplayName"), aname="_entityDisplayName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"assignedLicense"), aname="_assignedLicense", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"properties"), aname="_properties", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseAssignmentManagerLicenseAssignment_Def.__bases__: + bases = list(ns0.LicenseAssignmentManagerLicenseAssignment_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseAssignmentManagerLicenseAssignment_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLicenseAssignmentManagerLicenseAssignment_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLicenseAssignmentManagerLicenseAssignment") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLicenseAssignmentManagerLicenseAssignment_Def.schema + TClist = [GTD("urn:vim25","LicenseAssignmentManagerLicenseAssignment",lazy=True)(pname=(ns,"LicenseAssignmentManagerLicenseAssignment"), aname="_LicenseAssignmentManagerLicenseAssignment", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LicenseAssignmentManagerLicenseAssignment = [] + return + Holder.__name__ = "ArrayOfLicenseAssignmentManagerLicenseAssignment_Holder" + self.pyclass = Holder + + class LicenseAssignmentManagerEntityFeaturePair_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseAssignmentManagerEntityFeaturePair") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseAssignmentManagerEntityFeaturePair_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseAssignmentManagerEntityFeaturePair_Def.__bases__: + bases = list(ns0.LicenseAssignmentManagerEntityFeaturePair_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseAssignmentManagerEntityFeaturePair_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLicenseAssignmentManagerEntityFeaturePair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLicenseAssignmentManagerEntityFeaturePair") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLicenseAssignmentManagerEntityFeaturePair_Def.schema + TClist = [GTD("urn:vim25","LicenseAssignmentManagerEntityFeaturePair",lazy=True)(pname=(ns,"LicenseAssignmentManagerEntityFeaturePair"), aname="_LicenseAssignmentManagerEntityFeaturePair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LicenseAssignmentManagerEntityFeaturePair = [] + return + Holder.__name__ = "ArrayOfLicenseAssignmentManagerEntityFeaturePair_Holder" + self.pyclass = Holder + + class LicenseAssignmentManagerFeatureLicenseAvailability_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseAssignmentManagerFeatureLicenseAvailability") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.schema + TClist = [GTD("urn:vim25","LicenseAssignmentManagerEntityFeaturePair",lazy=True)(pname=(ns,"entityFeature"), aname="_entityFeature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"licensed"), aname="_licensed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.__bases__: + bases = list(ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability_Def.schema + TClist = [GTD("urn:vim25","LicenseAssignmentManagerFeatureLicenseAvailability",lazy=True)(pname=(ns,"LicenseAssignmentManagerFeatureLicenseAvailability"), aname="_LicenseAssignmentManagerFeatureLicenseAvailability", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LicenseAssignmentManagerFeatureLicenseAvailability = [] + return + Holder.__name__ = "ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability_Holder" + self.pyclass = Holder + + class UpdateAssignedLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateAssignedLicenseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateAssignedLicenseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityDisplayName"), aname="_entityDisplayName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._licenseKey = None + self._entityDisplayName = None + return + Holder.__name__ = "UpdateAssignedLicenseRequestType_Holder" + self.pyclass = Holder + + class RemoveAssignedLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveAssignedLicenseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveAssignedLicenseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entityId = None + return + Holder.__name__ = "RemoveAssignedLicenseRequestType_Holder" + self.pyclass = Holder + + class QueryAssignedLicensesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryAssignedLicensesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryAssignedLicensesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entityId = None + return + Holder.__name__ = "QueryAssignedLicensesRequestType_Holder" + self.pyclass = Holder + + class IsFeatureAvailableRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "IsFeatureAvailableRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.IsFeatureAvailableRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseAssignmentManagerEntityFeaturePair",lazy=True)(pname=(ns,"entityFeaturePair"), aname="_entityFeaturePair", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entityFeaturePair = [] + return + Holder.__name__ = "IsFeatureAvailableRequestType_Holder" + self.pyclass = Holder + + class SetFeatureInUseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetFeatureInUseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetFeatureInUseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entityId = None + self._feature = None + return + Holder.__name__ = "SetFeatureInUseRequestType_Holder" + self.pyclass = Holder + + class ResetFeatureInUseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetFeatureInUseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetFeatureInUseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entityId = None + self._feature = None + return + Holder.__name__ = "ResetFeatureInUseRequestType_Holder" + self.pyclass = Holder + + class LicenseManagerState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LicenseManagerState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LicenseManagerLicenseKey_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LicenseManagerLicenseKey") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LicenseSource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseSource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseSource_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseSource_Def.__bases__: + bases = list(ns0.LicenseSource_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseSource_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseServerSource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseServerSource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseServerSource_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseSource_Def not in ns0.LicenseServerSource_Def.__bases__: + bases = list(ns0.LicenseServerSource_Def.__bases__) + bases.insert(0, ns0.LicenseSource_Def) + ns0.LicenseServerSource_Def.__bases__ = tuple(bases) + + ns0.LicenseSource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LocalLicenseSource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LocalLicenseSource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LocalLicenseSource_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseKeys"), aname="_licenseKeys", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseSource_Def not in ns0.LocalLicenseSource_Def.__bases__: + bases = list(ns0.LocalLicenseSource_Def.__bases__) + bases.insert(0, ns0.LicenseSource_Def) + ns0.LocalLicenseSource_Def.__bases__ = tuple(bases) + + ns0.LicenseSource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EvaluationLicenseSource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EvaluationLicenseSource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EvaluationLicenseSource_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"remainingHours"), aname="_remainingHours", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseSource_Def not in ns0.EvaluationLicenseSource_Def.__bases__: + bases = list(ns0.EvaluationLicenseSource_Def.__bases__) + bases.insert(0, ns0.LicenseSource_Def) + ns0.EvaluationLicenseSource_Def.__bases__ = tuple(bases) + + ns0.LicenseSource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseFeatureInfoUnit_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LicenseFeatureInfoUnit") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LicenseFeatureInfoState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LicenseFeatureInfoState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LicenseFeatureInfoSourceRestriction_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LicenseFeatureInfoSourceRestriction") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LicenseFeatureInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseFeatureInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseFeatureInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureName"), aname="_featureName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureDescription"), aname="_featureDescription", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseFeatureInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"costUnit"), aname="_costUnit", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceRestriction"), aname="_sourceRestriction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dependentKey"), aname="_dependentKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"edition"), aname="_edition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"expiresOn"), aname="_expiresOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseFeatureInfo_Def.__bases__: + bases = list(ns0.LicenseFeatureInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseFeatureInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLicenseFeatureInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLicenseFeatureInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLicenseFeatureInfo_Def.schema + TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"LicenseFeatureInfo"), aname="_LicenseFeatureInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LicenseFeatureInfo = [] + return + Holder.__name__ = "ArrayOfLicenseFeatureInfo_Holder" + self.pyclass = Holder + + class LicenseReservationInfoState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LicenseReservationInfoState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LicenseReservationInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseReservationInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseReservationInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseReservationInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"required"), aname="_required", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseReservationInfo_Def.__bases__: + bases = list(ns0.LicenseReservationInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseReservationInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLicenseReservationInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLicenseReservationInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLicenseReservationInfo_Def.schema + TClist = [GTD("urn:vim25","LicenseReservationInfo",lazy=True)(pname=(ns,"LicenseReservationInfo"), aname="_LicenseReservationInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LicenseReservationInfo = [] + return + Holder.__name__ = "ArrayOfLicenseReservationInfo_Holder" + self.pyclass = Holder + + class LicenseAvailabilityInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseAvailabilityInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseAvailabilityInfo_Def.schema + TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"total"), aname="_total", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseAvailabilityInfo_Def.__bases__: + bases = list(ns0.LicenseAvailabilityInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseAvailabilityInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLicenseAvailabilityInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLicenseAvailabilityInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLicenseAvailabilityInfo_Def.schema + TClist = [GTD("urn:vim25","LicenseAvailabilityInfo",lazy=True)(pname=(ns,"LicenseAvailabilityInfo"), aname="_LicenseAvailabilityInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LicenseAvailabilityInfo = [] + return + Holder.__name__ = "ArrayOfLicenseAvailabilityInfo_Holder" + self.pyclass = Holder + + class LicenseDiagnostics_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseDiagnostics") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseDiagnostics_Def.schema + TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"sourceLastChanged"), aname="_sourceLastChanged", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceLost"), aname="_sourceLost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"sourceLatency"), aname="_sourceLatency", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseRequests"), aname="_licenseRequests", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseRequestFailures"), aname="_licenseRequestFailures", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseFeatureUnknowns"), aname="_licenseFeatureUnknowns", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseManagerState",lazy=True)(pname=(ns,"opState"), aname="_opState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastStatusUpdate"), aname="_lastStatusUpdate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"opFailureMessage"), aname="_opFailureMessage", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseDiagnostics_Def.__bases__: + bases = list(ns0.LicenseDiagnostics_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseDiagnostics_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseUsageInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseUsageInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseUsageInfo_Def.schema + TClist = [GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sourceAvailable"), aname="_sourceAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseReservationInfo",lazy=True)(pname=(ns,"reservationInfo"), aname="_reservationInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"featureInfo"), aname="_featureInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseUsageInfo_Def.__bases__: + bases = list(ns0.LicenseUsageInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseUsageInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseManagerEvaluationInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseManagerEvaluationInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseManagerEvaluationInfo_Def.schema + TClist = [GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"properties"), aname="_properties", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseManagerEvaluationInfo_Def.__bases__: + bases = list(ns0.LicenseManagerEvaluationInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseManagerEvaluationInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseManagerLicenseInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseManagerLicenseInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseManagerLicenseInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"editionKey"), aname="_editionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"total"), aname="_total", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"used"), aname="_used", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"costUnit"), aname="_costUnit", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"properties"), aname="_properties", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"labels"), aname="_labels", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LicenseManagerLicenseInfo_Def.__bases__: + bases = list(ns0.LicenseManagerLicenseInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LicenseManagerLicenseInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLicenseManagerLicenseInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLicenseManagerLicenseInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLicenseManagerLicenseInfo_Def.schema + TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"LicenseManagerLicenseInfo"), aname="_LicenseManagerLicenseInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LicenseManagerLicenseInfo = [] + return + Holder.__name__ = "ArrayOfLicenseManagerLicenseInfo_Holder" + self.pyclass = Holder + + class QuerySupportedFeaturesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QuerySupportedFeaturesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QuerySupportedFeaturesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "QuerySupportedFeaturesRequestType_Holder" + self.pyclass = Holder + + class QueryLicenseSourceAvailabilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryLicenseSourceAvailabilityRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryLicenseSourceAvailabilityRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "QueryLicenseSourceAvailabilityRequestType_Holder" + self.pyclass = Holder + + class QueryLicenseUsageRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryLicenseUsageRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryLicenseUsageRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "QueryLicenseUsageRequestType_Holder" + self.pyclass = Holder + + class SetLicenseEditionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetLicenseEditionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetLicenseEditionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._featureKey = None + return + Holder.__name__ = "SetLicenseEditionRequestType_Holder" + self.pyclass = Holder + + class CheckLicenseFeatureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckLicenseFeatureRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckLicenseFeatureRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._featureKey = None + return + Holder.__name__ = "CheckLicenseFeatureRequestType_Holder" + self.pyclass = Holder + + class EnableFeatureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EnableFeatureRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.EnableFeatureRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._featureKey = None + return + Holder.__name__ = "EnableFeatureRequestType_Holder" + self.pyclass = Holder + + class DisableFeatureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DisableFeatureRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DisableFeatureRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._featureKey = None + return + Holder.__name__ = "DisableFeatureRequestType_Holder" + self.pyclass = Holder + + class ConfigureLicenseSourceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ConfigureLicenseSourceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ConfigureLicenseSourceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"licenseSource"), aname="_licenseSource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._licenseSource = None + return + Holder.__name__ = "ConfigureLicenseSourceRequestType_Holder" + self.pyclass = Holder + + class UpdateLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateLicenseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateLicenseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"labels"), aname="_labels", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._licenseKey = None + self._labels = [] + return + Holder.__name__ = "UpdateLicenseRequestType_Holder" + self.pyclass = Holder + + class AddLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddLicenseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddLicenseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"labels"), aname="_labels", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._licenseKey = None + self._labels = [] + return + Holder.__name__ = "AddLicenseRequestType_Holder" + self.pyclass = Holder + + class RemoveLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveLicenseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveLicenseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._licenseKey = None + return + Holder.__name__ = "RemoveLicenseRequestType_Holder" + self.pyclass = Holder + + class DecodeLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DecodeLicenseRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DecodeLicenseRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._licenseKey = None + return + Holder.__name__ = "DecodeLicenseRequestType_Holder" + self.pyclass = Holder + + class UpdateLicenseLabelRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateLicenseLabelRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateLicenseLabelRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"labelKey"), aname="_labelKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"labelValue"), aname="_labelValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._licenseKey = None + self._labelKey = None + self._labelValue = None + return + Holder.__name__ = "UpdateLicenseLabelRequestType_Holder" + self.pyclass = Holder + + class RemoveLicenseLabelRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveLicenseLabelRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveLicenseLabelRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"labelKey"), aname="_labelKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._licenseKey = None + self._labelKey = None + return + Holder.__name__ = "RemoveLicenseLabelRequestType_Holder" + self.pyclass = Holder + + class LocalizationManagerMessageCatalog_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LocalizationManagerMessageCatalog") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LocalizationManagerMessageCatalog_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"moduleName"), aname="_moduleName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"catalogName"), aname="_catalogName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"catalogUri"), aname="_catalogUri", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModified"), aname="_lastModified", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"md5sum"), aname="_md5sum", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LocalizationManagerMessageCatalog_Def.__bases__: + bases = list(ns0.LocalizationManagerMessageCatalog_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LocalizationManagerMessageCatalog_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfLocalizationManagerMessageCatalog_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLocalizationManagerMessageCatalog") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLocalizationManagerMessageCatalog_Def.schema + TClist = [GTD("urn:vim25","LocalizationManagerMessageCatalog",lazy=True)(pname=(ns,"LocalizationManagerMessageCatalog"), aname="_LocalizationManagerMessageCatalog", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._LocalizationManagerMessageCatalog = [] + return + Holder.__name__ = "ArrayOfLocalizationManagerMessageCatalog_Holder" + self.pyclass = Holder + + class LongPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LongPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LongPolicy_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.LongPolicy_Def.__bases__: + bases = list(ns0.LongPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.LongPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ManagedEntityStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ManagedEntityStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ReloadRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReloadRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReloadRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ReloadRequestType_Holder" + self.pyclass = Holder + + class RenameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RenameRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RenameRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._newName = None + return + Holder.__name__ = "RenameRequestType_Holder" + self.pyclass = Holder + + class DestroyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DestroyRequestType_Holder" + self.pyclass = Holder + + class MethodDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MethodDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MethodDescription_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Description_Def not in ns0.MethodDescription_Def.__bases__: + bases = list(ns0.MethodDescription_Def.__bases__) + bases.insert(0, ns0.Description_Def) + ns0.MethodDescription_Def.__bases__ = tuple(bases) + + ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NetworkSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworkSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworkSummary_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"accessible"), aname="_accessible", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipPoolName"), aname="_ipPoolName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.NetworkSummary_Def.__bases__: + bases = list(ns0.NetworkSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.NetworkSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DestroyNetworkRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyNetworkRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyNetworkRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DestroyNetworkRequestType_Holder" + self.pyclass = Holder + + class NumericRange_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NumericRange") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NumericRange_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"start"), aname="_start", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"end"), aname="_end", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.NumericRange_Def.__bases__: + bases = list(ns0.NumericRange_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.NumericRange_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfNumericRange_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfNumericRange") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfNumericRange_Def.schema + TClist = [GTD("urn:vim25","NumericRange",lazy=True)(pname=(ns,"NumericRange"), aname="_NumericRange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._NumericRange = [] + return + Holder.__name__ = "ArrayOfNumericRange_Holder" + self.pyclass = Holder + + class OvfDeploymentOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfDeploymentOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfDeploymentOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfDeploymentOption_Def.__bases__: + bases = list(ns0.OvfDeploymentOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfDeploymentOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOvfDeploymentOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOvfDeploymentOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOvfDeploymentOption_Def.schema + TClist = [GTD("urn:vim25","OvfDeploymentOption",lazy=True)(pname=(ns,"OvfDeploymentOption"), aname="_OvfDeploymentOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OvfDeploymentOption = [] + return + Holder.__name__ = "ArrayOfOvfDeploymentOption_Holder" + self.pyclass = Holder + + class OvfManagerCommonParams_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfManagerCommonParams") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfManagerCommonParams_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deploymentOption"), aname="_deploymentOption", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"msgBundle"), aname="_msgBundle", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfManagerCommonParams_Def.__bases__: + bases = list(ns0.OvfManagerCommonParams_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfManagerCommonParams_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfValidateHostParams_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfValidateHostParams") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfValidateHostParams_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfManagerCommonParams_Def not in ns0.OvfValidateHostParams_Def.__bases__: + bases = list(ns0.OvfValidateHostParams_Def.__bases__) + bases.insert(0, ns0.OvfManagerCommonParams_Def) + ns0.OvfValidateHostParams_Def.__bases__ = tuple(bases) + + ns0.OvfManagerCommonParams_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfValidateHostResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfValidateHostResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfValidateHostResult_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"downloadSize"), aname="_downloadSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"flatDeploymentSize"), aname="_flatDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"sparseDeploymentSize"), aname="_sparseDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfValidateHostResult_Def.__bases__: + bases = list(ns0.OvfValidateHostResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfValidateHostResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfParseDescriptorParams_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfParseDescriptorParams") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfParseDescriptorParams_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfManagerCommonParams_Def not in ns0.OvfParseDescriptorParams_Def.__bases__: + bases = list(ns0.OvfParseDescriptorParams_Def.__bases__) + bases.insert(0, ns0.OvfManagerCommonParams_Def) + ns0.OvfParseDescriptorParams_Def.__bases__ = tuple(bases) + + ns0.OvfManagerCommonParams_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfParseDescriptorResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfParseDescriptorResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfParseDescriptorResult_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"eula"), aname="_eula", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAllocationScheme"), aname="_ipAllocationScheme", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipProtocols"), aname="_ipProtocols", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"approximateDownloadSize"), aname="_approximateDownloadSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"approximateFlatDeploymentSize"), aname="_approximateFlatDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"approximateSparseDeploymentSize"), aname="_approximateSparseDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultEntityName"), aname="_defaultEntityName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"virtualApp"), aname="_virtualApp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfDeploymentOption",lazy=True)(pname=(ns,"deploymentOption"), aname="_deploymentOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultDeploymentOption"), aname="_defaultDeploymentOption", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfParseDescriptorResult_Def.__bases__: + bases = list(ns0.OvfParseDescriptorResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfParseDescriptorResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfNetworkInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfNetworkInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfNetworkInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfNetworkInfo_Def.__bases__: + bases = list(ns0.OvfNetworkInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfNetworkInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOvfNetworkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOvfNetworkInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOvfNetworkInfo_Def.schema + TClist = [GTD("urn:vim25","OvfNetworkInfo",lazy=True)(pname=(ns,"OvfNetworkInfo"), aname="_OvfNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OvfNetworkInfo = [] + return + Holder.__name__ = "ArrayOfOvfNetworkInfo_Holder" + self.pyclass = Holder + + class OvfCreateImportSpecParams_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfCreateImportSpecParams") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfCreateImportSpecParams_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hostSystem"), aname="_hostSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfNetworkMapping",lazy=True)(pname=(ns,"networkMapping"), aname="_networkMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAllocationPolicy"), aname="_ipAllocationPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipProtocol"), aname="_ipProtocol", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"propertyMapping"), aname="_propertyMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfManagerCommonParams_Def not in ns0.OvfCreateImportSpecParams_Def.__bases__: + bases = list(ns0.OvfCreateImportSpecParams_Def.__bases__) + bases.insert(0, ns0.OvfManagerCommonParams_Def) + ns0.OvfCreateImportSpecParams_Def.__bases__ = tuple(bases) + + ns0.OvfManagerCommonParams_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfNetworkMapping_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfNetworkMapping") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfNetworkMapping_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfNetworkMapping_Def.__bases__: + bases = list(ns0.OvfNetworkMapping_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfNetworkMapping_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOvfNetworkMapping_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOvfNetworkMapping") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOvfNetworkMapping_Def.schema + TClist = [GTD("urn:vim25","OvfNetworkMapping",lazy=True)(pname=(ns,"OvfNetworkMapping"), aname="_OvfNetworkMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OvfNetworkMapping = [] + return + Holder.__name__ = "ArrayOfOvfNetworkMapping_Holder" + self.pyclass = Holder + + class OvfCreateImportSpecResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfCreateImportSpecResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfCreateImportSpecResult_Def.schema + TClist = [GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"importSpec"), aname="_importSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfFileItem",lazy=True)(pname=(ns,"fileItem"), aname="_fileItem", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfCreateImportSpecResult_Def.__bases__: + bases = list(ns0.OvfCreateImportSpecResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfCreateImportSpecResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfFileItem_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfFileItem") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfFileItem_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compressionMethod"), aname="_compressionMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"chunkSize"), aname="_chunkSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cimType"), aname="_cimType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"create"), aname="_create", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfFileItem_Def.__bases__: + bases = list(ns0.OvfFileItem_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfFileItem_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOvfFileItem_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOvfFileItem") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOvfFileItem_Def.schema + TClist = [GTD("urn:vim25","OvfFileItem",lazy=True)(pname=(ns,"OvfFileItem"), aname="_OvfFileItem", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OvfFileItem = [] + return + Holder.__name__ = "ArrayOfOvfFileItem_Holder" + self.pyclass = Holder + + class OvfCreateDescriptorParams_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfCreateDescriptorParams") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfCreateDescriptorParams_Def.schema + TClist = [GTD("urn:vim25","OvfFile",lazy=True)(pname=(ns,"ovfFiles"), aname="_ovfFiles", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfCreateDescriptorParams_Def.__bases__: + bases = list(ns0.OvfCreateDescriptorParams_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfCreateDescriptorParams_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfCreateDescriptorResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfCreateDescriptorResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfCreateDescriptorResult_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfCreateDescriptorResult_Def.__bases__: + bases = list(ns0.OvfCreateDescriptorResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfCreateDescriptorResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfFile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfFile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfFile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compressionMethod"), aname="_compressionMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"chunkSize"), aname="_chunkSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OvfFile_Def.__bases__: + bases = list(ns0.OvfFile_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OvfFile_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOvfFile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOvfFile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOvfFile_Def.schema + TClist = [GTD("urn:vim25","OvfFile",lazy=True)(pname=(ns,"OvfFile"), aname="_OvfFile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OvfFile = [] + return + Holder.__name__ = "ArrayOfOvfFile_Holder" + self.pyclass = Holder + + class ValidateHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ValidateHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ValidateHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfValidateHostParams",lazy=True)(pname=(ns,"vhp"), aname="_vhp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._ovfDescriptor = None + self._host = None + self._vhp = None + return + Holder.__name__ = "ValidateHostRequestType_Holder" + self.pyclass = Holder + + class ParseDescriptorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ParseDescriptorRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ParseDescriptorRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfParseDescriptorParams",lazy=True)(pname=(ns,"pdp"), aname="_pdp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._ovfDescriptor = None + self._pdp = None + return + Holder.__name__ = "ParseDescriptorRequestType_Holder" + self.pyclass = Holder + + class CreateImportSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateImportSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateImportSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfCreateImportSpecParams",lazy=True)(pname=(ns,"cisp"), aname="_cisp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._ovfDescriptor = None + self._resourcePool = None + self._datastore = None + self._cisp = None + return + Holder.__name__ = "CreateImportSpecRequestType_Holder" + self.pyclass = Holder + + class CreateDescriptorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateDescriptorRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateDescriptorRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfCreateDescriptorParams",lazy=True)(pname=(ns,"cdp"), aname="_cdp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._obj = None + self._cdp = None + return + Holder.__name__ = "CreateDescriptorRequestType_Holder" + self.pyclass = Holder + + class PasswordField_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PasswordField") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PasswordField_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PasswordField_Def.__bases__: + bases = list(ns0.PasswordField_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PasswordField_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PerformanceDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerformanceDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerformanceDescription_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"counterType"), aname="_counterType", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"statsType"), aname="_statsType", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerformanceDescription_Def.__bases__: + bases = list(ns0.PerformanceDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerformanceDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PerfFormat_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PerfFormat") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class PerfProviderSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfProviderSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfProviderSummary_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"currentSupported"), aname="_currentSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"summarySupported"), aname="_summarySupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"refreshRate"), aname="_refreshRate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfProviderSummary_Def.__bases__: + bases = list(ns0.PerfProviderSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfProviderSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PerfSummaryType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PerfSummaryType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class PerfStatsType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PerfStatsType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class PerformanceManagerUnit_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PerformanceManagerUnit") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class PerfCounterInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfCounterInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfCounterInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"nameInfo"), aname="_nameInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"groupInfo"), aname="_groupInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"unitInfo"), aname="_unitInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfSummaryType",lazy=True)(pname=(ns,"rollupType"), aname="_rollupType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfStatsType",lazy=True)(pname=(ns,"statsType"), aname="_statsType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"associatedCounterId"), aname="_associatedCounterId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfCounterInfo_Def.__bases__: + bases = list(ns0.PerfCounterInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfCounterInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfCounterInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfCounterInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfCounterInfo_Def.schema + TClist = [GTD("urn:vim25","PerfCounterInfo",lazy=True)(pname=(ns,"PerfCounterInfo"), aname="_PerfCounterInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfCounterInfo = [] + return + Holder.__name__ = "ArrayOfPerfCounterInfo_Holder" + self.pyclass = Holder + + class PerfMetricId_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfMetricId") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfMetricId_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"counterId"), aname="_counterId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instance"), aname="_instance", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfMetricId_Def.__bases__: + bases = list(ns0.PerfMetricId_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfMetricId_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfMetricId_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfMetricId") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfMetricId_Def.schema + TClist = [GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"PerfMetricId"), aname="_PerfMetricId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfMetricId = [] + return + Holder.__name__ = "ArrayOfPerfMetricId_Holder" + self.pyclass = Holder + + class PerfQuerySpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfQuerySpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfQuerySpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"startTime"), aname="_startTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSample"), aname="_maxSample", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"metricId"), aname="_metricId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"intervalId"), aname="_intervalId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"format"), aname="_format", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfQuerySpec_Def.__bases__: + bases = list(ns0.PerfQuerySpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfQuerySpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfQuerySpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfQuerySpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfQuerySpec_Def.schema + TClist = [GTD("urn:vim25","PerfQuerySpec",lazy=True)(pname=(ns,"PerfQuerySpec"), aname="_PerfQuerySpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfQuerySpec = [] + return + Holder.__name__ = "ArrayOfPerfQuerySpec_Holder" + self.pyclass = Holder + + class PerfSampleInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfSampleInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfSampleInfo_Def.schema + TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfSampleInfo_Def.__bases__: + bases = list(ns0.PerfSampleInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfSampleInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfSampleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfSampleInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfSampleInfo_Def.schema + TClist = [GTD("urn:vim25","PerfSampleInfo",lazy=True)(pname=(ns,"PerfSampleInfo"), aname="_PerfSampleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfSampleInfo = [] + return + Holder.__name__ = "ArrayOfPerfSampleInfo_Holder" + self.pyclass = Holder + + class PerfMetricSeries_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfMetricSeries") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfMetricSeries_Def.schema + TClist = [GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfMetricSeries_Def.__bases__: + bases = list(ns0.PerfMetricSeries_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfMetricSeries_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfMetricSeries_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfMetricSeries") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfMetricSeries_Def.schema + TClist = [GTD("urn:vim25","PerfMetricSeries",lazy=True)(pname=(ns,"PerfMetricSeries"), aname="_PerfMetricSeries", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfMetricSeries = [] + return + Holder.__name__ = "ArrayOfPerfMetricSeries_Holder" + self.pyclass = Holder + + class PerfMetricIntSeries_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfMetricIntSeries") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfMetricIntSeries_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PerfMetricSeries_Def not in ns0.PerfMetricIntSeries_Def.__bases__: + bases = list(ns0.PerfMetricIntSeries_Def.__bases__) + bases.insert(0, ns0.PerfMetricSeries_Def) + ns0.PerfMetricIntSeries_Def.__bases__ = tuple(bases) + + ns0.PerfMetricSeries_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PerfMetricSeriesCSV_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfMetricSeriesCSV") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfMetricSeriesCSV_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PerfMetricSeries_Def not in ns0.PerfMetricSeriesCSV_Def.__bases__: + bases = list(ns0.PerfMetricSeriesCSV_Def.__bases__) + bases.insert(0, ns0.PerfMetricSeries_Def) + ns0.PerfMetricSeriesCSV_Def.__bases__ = tuple(bases) + + ns0.PerfMetricSeries_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfMetricSeriesCSV_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfMetricSeriesCSV") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfMetricSeriesCSV_Def.schema + TClist = [GTD("urn:vim25","PerfMetricSeriesCSV",lazy=True)(pname=(ns,"PerfMetricSeriesCSV"), aname="_PerfMetricSeriesCSV", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfMetricSeriesCSV = [] + return + Holder.__name__ = "ArrayOfPerfMetricSeriesCSV_Holder" + self.pyclass = Holder + + class PerfEntityMetricBase_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfEntityMetricBase") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfEntityMetricBase_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfEntityMetricBase_Def.__bases__: + bases = list(ns0.PerfEntityMetricBase_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfEntityMetricBase_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfEntityMetricBase_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfEntityMetricBase") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfEntityMetricBase_Def.schema + TClist = [GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"PerfEntityMetricBase"), aname="_PerfEntityMetricBase", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfEntityMetricBase = [] + return + Holder.__name__ = "ArrayOfPerfEntityMetricBase_Holder" + self.pyclass = Holder + + class PerfEntityMetric_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfEntityMetric") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfEntityMetric_Def.schema + TClist = [GTD("urn:vim25","PerfSampleInfo",lazy=True)(pname=(ns,"sampleInfo"), aname="_sampleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricSeries",lazy=True)(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PerfEntityMetricBase_Def not in ns0.PerfEntityMetric_Def.__bases__: + bases = list(ns0.PerfEntityMetric_Def.__bases__) + bases.insert(0, ns0.PerfEntityMetricBase_Def) + ns0.PerfEntityMetric_Def.__bases__ = tuple(bases) + + ns0.PerfEntityMetricBase_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PerfEntityMetricCSV_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfEntityMetricCSV") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfEntityMetricCSV_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"sampleInfoCSV"), aname="_sampleInfoCSV", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricSeriesCSV",lazy=True)(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PerfEntityMetricBase_Def not in ns0.PerfEntityMetricCSV_Def.__bases__: + bases = list(ns0.PerfEntityMetricCSV_Def.__bases__) + bases.insert(0, ns0.PerfEntityMetricBase_Def) + ns0.PerfEntityMetricCSV_Def.__bases__ = tuple(bases) + + ns0.PerfEntityMetricBase_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PerfCompositeMetric_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfCompositeMetric") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfCompositeMetric_Def.schema + TClist = [GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"childEntity"), aname="_childEntity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfCompositeMetric_Def.__bases__: + bases = list(ns0.PerfCompositeMetric_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfCompositeMetric_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class QueryPerfProviderSummaryRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPerfProviderSummaryRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPerfProviderSummaryRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + return + Holder.__name__ = "QueryPerfProviderSummaryRequestType_Holder" + self.pyclass = Holder + + class QueryAvailablePerfMetricRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryAvailablePerfMetricRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryAvailablePerfMetricRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"beginTime"), aname="_beginTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"intervalId"), aname="_intervalId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._beginTime = None + self._endTime = None + self._intervalId = None + return + Holder.__name__ = "QueryAvailablePerfMetricRequestType_Holder" + self.pyclass = Holder + + class QueryPerfCounterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPerfCounterRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPerfCounterRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"counterId"), aname="_counterId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._counterId = [] + return + Holder.__name__ = "QueryPerfCounterRequestType_Holder" + self.pyclass = Holder + + class QueryPerfCounterByLevelRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPerfCounterByLevelRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPerfCounterByLevelRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._level = None + return + Holder.__name__ = "QueryPerfCounterByLevelRequestType_Holder" + self.pyclass = Holder + + class QueryPerfRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPerfRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPerfRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfQuerySpec",lazy=True)(pname=(ns,"querySpec"), aname="_querySpec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._querySpec = [] + return + Holder.__name__ = "QueryPerfRequestType_Holder" + self.pyclass = Holder + + class QueryPerfCompositeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPerfCompositeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPerfCompositeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfQuerySpec",lazy=True)(pname=(ns,"querySpec"), aname="_querySpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._querySpec = None + return + Holder.__name__ = "QueryPerfCompositeRequestType_Holder" + self.pyclass = Holder + + class CreatePerfIntervalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreatePerfIntervalRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreatePerfIntervalRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"intervalId"), aname="_intervalId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._intervalId = None + return + Holder.__name__ = "CreatePerfIntervalRequestType_Holder" + self.pyclass = Holder + + class RemovePerfIntervalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemovePerfIntervalRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemovePerfIntervalRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"samplePeriod"), aname="_samplePeriod", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._samplePeriod = None + return + Holder.__name__ = "RemovePerfIntervalRequestType_Holder" + self.pyclass = Holder + + class UpdatePerfIntervalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdatePerfIntervalRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdatePerfIntervalRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._interval = None + return + Holder.__name__ = "UpdatePerfIntervalRequestType_Holder" + self.pyclass = Holder + + class PerfInterval_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerfInterval") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerfInterval_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"samplingPeriod"), aname="_samplingPeriod", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"length"), aname="_length", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerfInterval_Def.__bases__: + bases = list(ns0.PerfInterval_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerfInterval_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPerfInterval_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPerfInterval") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPerfInterval_Def.schema + TClist = [GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"PerfInterval"), aname="_PerfInterval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PerfInterval = [] + return + Holder.__name__ = "ArrayOfPerfInterval_Holder" + self.pyclass = Holder + + class PosixUserSearchResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PosixUserSearchResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PosixUserSearchResult_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shellAccess"), aname="_shellAccess", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.UserSearchResult_Def not in ns0.PosixUserSearchResult_Def.__bases__: + bases = list(ns0.PosixUserSearchResult_Def.__bases__) + bases.insert(0, ns0.UserSearchResult_Def) + ns0.PosixUserSearchResult_Def.__bases__ = tuple(bases) + + ns0.UserSearchResult_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PrivilegePolicyDef_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PrivilegePolicyDef") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PrivilegePolicyDef_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"createPrivilege"), aname="_createPrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"readPrivilege"), aname="_readPrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"updatePrivilege"), aname="_updatePrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deletePrivilege"), aname="_deletePrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PrivilegePolicyDef_Def.__bases__: + bases = list(ns0.PrivilegePolicyDef_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PrivilegePolicyDef_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourceAllocationInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourceAllocationInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourceAllocationInfo_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"reservation"), aname="_reservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"expandableReservation"), aname="_expandableReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"limit"), aname="_limit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SharesInfo",lazy=True)(pname=(ns,"shares"), aname="_shares", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overheadLimit"), aname="_overheadLimit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ResourceAllocationInfo_Def.__bases__: + bases = list(ns0.ResourceAllocationInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ResourceAllocationInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourceConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourceConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourceConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModified"), aname="_lastModified", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"cpuAllocation"), aname="_cpuAllocation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"memoryAllocation"), aname="_memoryAllocation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ResourceConfigSpec_Def.__bases__: + bases = list(ns0.ResourceConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ResourceConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfResourceConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfResourceConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfResourceConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"ResourceConfigSpec"), aname="_ResourceConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ResourceConfigSpec = [] + return + Holder.__name__ = "ArrayOfResourceConfigSpec_Holder" + self.pyclass = Holder + + class DatabaseSizeParam_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatabaseSizeParam") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatabaseSizeParam_Def.schema + TClist = [GTD("urn:vim25","InventoryDescription",lazy=True)(pname=(ns,"inventoryDesc"), aname="_inventoryDesc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerformanceStatisticsDescription",lazy=True)(pname=(ns,"perfStatsDesc"), aname="_perfStatsDesc", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatabaseSizeParam_Def.__bases__: + bases = list(ns0.DatabaseSizeParam_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatabaseSizeParam_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InventoryDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InventoryDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InventoryDescription_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numHosts"), aname="_numHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVirtualMachines"), aname="_numVirtualMachines", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numResourcePools"), aname="_numResourcePools", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numClusters"), aname="_numClusters", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuDev"), aname="_numCpuDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNetDev"), aname="_numNetDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numDiskDev"), aname="_numDiskDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numvCpuDev"), aname="_numvCpuDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numvNetDev"), aname="_numvNetDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numvDiskDev"), aname="_numvDiskDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.InventoryDescription_Def.__bases__: + bases = list(ns0.InventoryDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.InventoryDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PerformanceStatisticsDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PerformanceStatisticsDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PerformanceStatisticsDescription_Def.schema + TClist = [GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"intervals"), aname="_intervals", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PerformanceStatisticsDescription_Def.__bases__: + bases = list(ns0.PerformanceStatisticsDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PerformanceStatisticsDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatabaseSizeEstimate_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatabaseSizeEstimate") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatabaseSizeEstimate_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatabaseSizeEstimate_Def.__bases__: + bases = list(ns0.DatabaseSizeEstimate_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatabaseSizeEstimate_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GetDatabaseSizeEstimateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "GetDatabaseSizeEstimateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.GetDatabaseSizeEstimateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatabaseSizeParam",lazy=True)(pname=(ns,"dbSizeParam"), aname="_dbSizeParam", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dbSizeParam = None + return + Holder.__name__ = "GetDatabaseSizeEstimateRequestType_Holder" + self.pyclass = Holder + + class ResourcePoolResourceUsage_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolResourceUsage") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolResourceUsage_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"reservationUsed"), aname="_reservationUsed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"reservationUsedForVm"), aname="_reservationUsedForVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unreservedForPool"), aname="_unreservedForPool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unreservedForVm"), aname="_unreservedForVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overallUsage"), aname="_overallUsage", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxUsage"), aname="_maxUsage", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ResourcePoolResourceUsage_Def.__bases__: + bases = list(ns0.ResourcePoolResourceUsage_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ResourcePoolResourceUsage_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolRuntimeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolRuntimeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolRuntimeInfo_Def.schema + TClist = [GTD("urn:vim25","ResourcePoolResourceUsage",lazy=True)(pname=(ns,"memory"), aname="_memory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolResourceUsage",lazy=True)(pname=(ns,"cpu"), aname="_cpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ResourcePoolRuntimeInfo_Def.__bases__: + bases = list(ns0.ResourcePoolRuntimeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ResourcePoolRuntimeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolQuickStats_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolQuickStats") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolQuickStats_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"overallCpuUsage"), aname="_overallCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overallCpuDemand"), aname="_overallCpuDemand", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"guestMemoryUsage"), aname="_guestMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hostMemoryUsage"), aname="_hostMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"distributedCpuEntitlement"), aname="_distributedCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"distributedMemoryEntitlement"), aname="_distributedMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticCpuEntitlement"), aname="_staticCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticMemoryEntitlement"), aname="_staticMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"privateMemory"), aname="_privateMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"sharedMemory"), aname="_sharedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"swappedMemory"), aname="_swappedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"balloonedMemory"), aname="_balloonedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overheadMemory"), aname="_overheadMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"consumedOverheadMemory"), aname="_consumedOverheadMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ResourcePoolQuickStats_Def.__bases__: + bases = list(ns0.ResourcePoolQuickStats_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ResourcePoolQuickStats_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolSummary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolRuntimeInfo",lazy=True)(pname=(ns,"runtime"), aname="_runtime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolQuickStats",lazy=True)(pname=(ns,"quickStats"), aname="_quickStats", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"configuredMemoryMB"), aname="_configuredMemoryMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ResourcePoolSummary_Def.__bases__: + bases = list(ns0.ResourcePoolSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ResourcePoolSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._config = None + return + Holder.__name__ = "UpdateConfigRequestType_Holder" + self.pyclass = Holder + + class MoveIntoResourcePoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MoveIntoResourcePoolRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MoveIntoResourcePoolRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"list"), aname="_list", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._list = [] + return + Holder.__name__ = "MoveIntoResourcePoolRequestType_Holder" + self.pyclass = Holder + + class UpdateChildResourceConfigurationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateChildResourceConfigurationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateChildResourceConfigurationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = [] + return + Holder.__name__ = "UpdateChildResourceConfigurationRequestType_Holder" + self.pyclass = Holder + + class CreateResourcePoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateResourcePoolRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateResourcePoolRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._spec = None + return + Holder.__name__ = "CreateResourcePoolRequestType_Holder" + self.pyclass = Holder + + class DestroyChildrenRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyChildrenRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyChildrenRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DestroyChildrenRequestType_Holder" + self.pyclass = Holder + + class CreateVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateVAppRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateVAppRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"resSpec"), aname="_resSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmFolder"), aname="_vmFolder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._resSpec = None + self._configSpec = None + self._vmFolder = None + return + Holder.__name__ = "CreateVAppRequestType_Holder" + self.pyclass = Holder + + class CreateChildVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateChildVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateChildVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + self._host = None + return + Holder.__name__ = "CreateChildVMRequestType_Holder" + self.pyclass = Holder + + class RegisterChildVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RegisterChildVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RegisterChildVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._path = None + self._name = None + self._host = None + return + Holder.__name__ = "RegisterChildVMRequestType_Holder" + self.pyclass = Holder + + class ImportVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ImportVAppRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ImportVAppRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"folder"), aname="_folder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + self._folder = None + self._host = None + return + Holder.__name__ = "ImportVAppRequestType_Holder" + self.pyclass = Holder + + class FindByUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindByUuidRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindByUuidRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datacenter = None + self._uuid = None + self._vmSearch = None + self._instanceUuid = None + return + Holder.__name__ = "FindByUuidRequestType_Holder" + self.pyclass = Holder + + class FindByDatastorePathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindByDatastorePathRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindByDatastorePathRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datacenter = None + self._path = None + return + Holder.__name__ = "FindByDatastorePathRequestType_Holder" + self.pyclass = Holder + + class FindByDnsNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindByDnsNameRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindByDnsNameRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsName"), aname="_dnsName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datacenter = None + self._dnsName = None + self._vmSearch = None + return + Holder.__name__ = "FindByDnsNameRequestType_Holder" + self.pyclass = Holder + + class FindByIpRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindByIpRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindByIpRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datacenter = None + self._ip = None + self._vmSearch = None + return + Holder.__name__ = "FindByIpRequestType_Holder" + self.pyclass = Holder + + class FindByInventoryPathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindByInventoryPathRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindByInventoryPathRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"inventoryPath"), aname="_inventoryPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._inventoryPath = None + return + Holder.__name__ = "FindByInventoryPathRequestType_Holder" + self.pyclass = Holder + + class FindChildRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindChildRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindChildRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._name = None + return + Holder.__name__ = "FindChildRequestType_Holder" + self.pyclass = Holder + + class FindAllByUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindAllByUuidRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindAllByUuidRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datacenter = None + self._uuid = None + self._vmSearch = None + self._instanceUuid = None + return + Holder.__name__ = "FindAllByUuidRequestType_Holder" + self.pyclass = Holder + + class FindAllByDnsNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindAllByDnsNameRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindAllByDnsNameRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsName"), aname="_dnsName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datacenter = None + self._dnsName = None + self._vmSearch = None + return + Holder.__name__ = "FindAllByDnsNameRequestType_Holder" + self.pyclass = Holder + + class FindAllByIpRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FindAllByIpRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FindAllByIpRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datacenter = None + self._ip = None + self._vmSearch = None + return + Holder.__name__ = "FindAllByIpRequestType_Holder" + self.pyclass = Holder + + class ValidateMigrationTestType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ValidateMigrationTestType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VMotionCompatibilityType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VMotionCompatibilityType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostVMotionCompatibility_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVMotionCompatibility") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVMotionCompatibility_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compatibility"), aname="_compatibility", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVMotionCompatibility_Def.__bases__: + bases = list(ns0.HostVMotionCompatibility_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVMotionCompatibility_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostVMotionCompatibility_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostVMotionCompatibility") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostVMotionCompatibility_Def.schema + TClist = [GTD("urn:vim25","HostVMotionCompatibility",lazy=True)(pname=(ns,"HostVMotionCompatibility"), aname="_HostVMotionCompatibility", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostVMotionCompatibility = [] + return + Holder.__name__ = "ArrayOfHostVMotionCompatibility_Holder" + self.pyclass = Holder + + class ProductComponentInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProductComponentInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProductComponentInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"release"), aname="_release", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProductComponentInfo_Def.__bases__: + bases = list(ns0.ProductComponentInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProductComponentInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProductComponentInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProductComponentInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProductComponentInfo_Def.schema + TClist = [GTD("urn:vim25","ProductComponentInfo",lazy=True)(pname=(ns,"ProductComponentInfo"), aname="_ProductComponentInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProductComponentInfo = [] + return + Holder.__name__ = "ArrayOfProductComponentInfo_Holder" + self.pyclass = Holder + + class CurrentTimeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CurrentTimeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CurrentTimeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "CurrentTimeRequestType_Holder" + self.pyclass = Holder + + class RetrieveServiceContentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveServiceContentRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveServiceContentRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RetrieveServiceContentRequestType_Holder" + self.pyclass = Holder + + class ValidateMigrationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ValidateMigrationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ValidateMigrationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = [] + self._state = None + self._testType = [] + self._pool = None + self._host = None + return + Holder.__name__ = "ValidateMigrationRequestType_Holder" + self.pyclass = Holder + + class QueryVMotionCompatibilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVMotionCompatibilityRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVMotionCompatibilityRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compatibility"), aname="_compatibility", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + self._host = [] + self._compatibility = [] + return + Holder.__name__ = "QueryVMotionCompatibilityRequestType_Holder" + self.pyclass = Holder + + class RetrieveProductComponentsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveProductComponentsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveProductComponentsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RetrieveProductComponentsRequestType_Holder" + self.pyclass = Holder + + class ServiceContent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ServiceContent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ServiceContent_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"rootFolder"), aname="_rootFolder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"propertyCollector"), aname="_propertyCollector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"viewManager"), aname="_viewManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AboutInfo",lazy=True)(pname=(ns,"about"), aname="_about", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"userDirectory"), aname="_userDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sessionManager"), aname="_sessionManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"authorizationManager"), aname="_authorizationManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"perfManager"), aname="_perfManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTaskManager"), aname="_scheduledTaskManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarmManager"), aname="_alarmManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"eventManager"), aname="_eventManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"taskManager"), aname="_taskManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"extensionManager"), aname="_extensionManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"customizationSpecManager"), aname="_customizationSpecManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"customFieldsManager"), aname="_customFieldsManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"accountManager"), aname="_accountManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"diagnosticManager"), aname="_diagnosticManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"licenseManager"), aname="_licenseManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"searchIndex"), aname="_searchIndex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"fileManager"), aname="_fileManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"virtualDiskManager"), aname="_virtualDiskManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"virtualizationManager"), aname="_virtualizationManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snmpSystem"), aname="_snmpSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmProvisioningChecker"), aname="_vmProvisioningChecker", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmCompatibilityChecker"), aname="_vmCompatibilityChecker", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"ovfManager"), aname="_ovfManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"ipPoolManager"), aname="_ipPoolManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvSwitchManager"), aname="_dvSwitchManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hostProfileManager"), aname="_hostProfileManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"clusterProfileManager"), aname="_clusterProfileManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"complianceManager"), aname="_complianceManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"localizationManager"), aname="_localizationManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ServiceContent_Def.__bases__: + bases = list(ns0.ServiceContent_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ServiceContent_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SessionManagerLocalTicket_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SessionManagerLocalTicket") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SessionManagerLocalTicket_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"passwordFilePath"), aname="_passwordFilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.SessionManagerLocalTicket_Def.__bases__: + bases = list(ns0.SessionManagerLocalTicket_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.SessionManagerLocalTicket_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateServiceMessageRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateServiceMessageRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateServiceMessageRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._message = None + return + Holder.__name__ = "UpdateServiceMessageRequestType_Holder" + self.pyclass = Holder + + class LoginRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LoginRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.LoginRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._userName = None + self._password = None + self._locale = None + return + Holder.__name__ = "LoginRequestType_Holder" + self.pyclass = Holder + + class LoginBySSPIRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LoginBySSPIRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.LoginBySSPIRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"base64Token"), aname="_base64Token", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._base64Token = None + self._locale = None + return + Holder.__name__ = "LoginBySSPIRequestType_Holder" + self.pyclass = Holder + + class LogoutRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LogoutRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.LogoutRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "LogoutRequestType_Holder" + self.pyclass = Holder + + class AcquireLocalTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AcquireLocalTicketRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AcquireLocalTicketRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._userName = None + return + Holder.__name__ = "AcquireLocalTicketRequestType_Holder" + self.pyclass = Holder + + class TerminateSessionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "TerminateSessionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.TerminateSessionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._sessionId = [] + return + Holder.__name__ = "TerminateSessionRequestType_Holder" + self.pyclass = Holder + + class SetLocaleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetLocaleRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetLocaleRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._locale = None + return + Holder.__name__ = "SetLocaleRequestType_Holder" + self.pyclass = Holder + + class LoginExtensionBySubjectNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LoginExtensionBySubjectNameRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.LoginExtensionBySubjectNameRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._extensionKey = None + self._locale = None + return + Holder.__name__ = "LoginExtensionBySubjectNameRequestType_Holder" + self.pyclass = Holder + + class ImpersonateUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ImpersonateUserRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ImpersonateUserRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._userName = None + self._locale = None + return + Holder.__name__ = "ImpersonateUserRequestType_Holder" + self.pyclass = Holder + + class SessionIsActiveRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SessionIsActiveRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SessionIsActiveRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionID"), aname="_sessionID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._sessionID = None + self._userName = None + return + Holder.__name__ = "SessionIsActiveRequestType_Holder" + self.pyclass = Holder + + class AcquireCloneTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AcquireCloneTicketRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AcquireCloneTicketRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "AcquireCloneTicketRequestType_Holder" + self.pyclass = Holder + + class CloneSessionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CloneSessionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CloneSessionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cloneTicket"), aname="_cloneTicket", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._cloneTicket = None + return + Holder.__name__ = "CloneSessionRequestType_Holder" + self.pyclass = Holder + + class UserSession_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserSession") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserSession_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"loginTime"), aname="_loginTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastActiveTime"), aname="_lastActiveTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"messageLocale"), aname="_messageLocale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.UserSession_Def.__bases__: + bases = list(ns0.UserSession_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.UserSession_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfUserSession_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfUserSession") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfUserSession_Def.schema + TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"UserSession"), aname="_UserSession", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._UserSession = [] + return + Holder.__name__ = "ArrayOfUserSession_Holder" + self.pyclass = Holder + + class SharesLevel_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SharesLevel") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class SharesInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SharesInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SharesInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"shares"), aname="_shares", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SharesLevel",lazy=True)(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.SharesInfo_Def.__bases__: + bases = list(ns0.SharesInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.SharesInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class StringPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "StringPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.StringPolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.StringPolicy_Def.__bases__: + bases = list(ns0.StringPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.StringPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class Tag_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Tag") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Tag_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.Tag_Def.__bases__: + bases = list(ns0.Tag_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.Tag_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfTag_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfTag") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfTag_Def.schema + TClist = [GTD("urn:vim25","Tag",lazy=True)(pname=(ns,"Tag"), aname="_Tag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._Tag = [] + return + Holder.__name__ = "ArrayOfTag_Holder" + self.pyclass = Holder + + class CancelTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CancelTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CancelTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "CancelTaskRequestType_Holder" + self.pyclass = Holder + + class UpdateProgressRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateProgressRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateProgressRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"percentDone"), aname="_percentDone", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._percentDone = None + return + Holder.__name__ = "UpdateProgressRequestType_Holder" + self.pyclass = Holder + + class SetTaskStateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetTaskStateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetTaskStateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"result"), aname="_result", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._state = None + self._result = None + self._fault = None + return + Holder.__name__ = "SetTaskStateRequestType_Holder" + self.pyclass = Holder + + class SetTaskDescriptionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetTaskDescriptionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetTaskDescriptionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._description = None + return + Holder.__name__ = "SetTaskDescriptionRequestType_Holder" + self.pyclass = Holder + + class TaskDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskDescription_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"methodInfo"), aname="_methodInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskDescription_Def.__bases__: + bases = list(ns0.TaskDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskFilterSpecRecursionOption_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "TaskFilterSpecRecursionOption") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class TaskFilterSpecTimeOption_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "TaskFilterSpecTimeOption") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class TaskFilterSpecByEntity_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskFilterSpecByEntity") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskFilterSpecByEntity_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpecRecursionOption",lazy=True)(pname=(ns,"recursion"), aname="_recursion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskFilterSpecByEntity_Def.__bases__: + bases = list(ns0.TaskFilterSpecByEntity_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskFilterSpecByEntity_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskFilterSpecByTime_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskFilterSpecByTime") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskFilterSpecByTime_Def.schema + TClist = [GTD("urn:vim25","TaskFilterSpecTimeOption",lazy=True)(pname=(ns,"timeType"), aname="_timeType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"beginTime"), aname="_beginTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskFilterSpecByTime_Def.__bases__: + bases = list(ns0.TaskFilterSpecByTime_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskFilterSpecByTime_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskFilterSpecByUsername_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskFilterSpecByUsername") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskFilterSpecByUsername_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"systemUser"), aname="_systemUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userList"), aname="_userList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskFilterSpecByUsername_Def.__bases__: + bases = list(ns0.TaskFilterSpecByUsername_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskFilterSpecByUsername_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskFilterSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskFilterSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskFilterSpec_Def.schema + TClist = [GTD("urn:vim25","TaskFilterSpecByEntity",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpecByTime",lazy=True)(pname=(ns,"time"), aname="_time", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpecByUsername",lazy=True)(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"eventChainId"), aname="_eventChainId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"tag"), aname="_tag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentTaskKey"), aname="_parentTaskKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rootTaskKey"), aname="_rootTaskKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskFilterSpec_Def.__bases__: + bases = list(ns0.TaskFilterSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskFilterSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReadNextTasksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReadNextTasksRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReadNextTasksRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._maxCount = None + return + Holder.__name__ = "ReadNextTasksRequestType_Holder" + self.pyclass = Holder + + class ReadPreviousTasksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReadPreviousTasksRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReadPreviousTasksRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._maxCount = None + return + Holder.__name__ = "ReadPreviousTasksRequestType_Holder" + self.pyclass = Holder + + class TaskInfoState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "TaskInfoState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ArrayOfTaskInfoState_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfTaskInfoState") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfTaskInfoState_Def.schema + TClist = [GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"TaskInfoState"), aname="_TaskInfoState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._TaskInfoState = [] + return + Holder.__name__ = "ArrayOfTaskInfoState_Holder" + self.pyclass = Holder + + class TaskInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"task"), aname="_task", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"descriptionId"), aname="_descriptionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"locked"), aname="_locked", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelled"), aname="_cancelled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelable"), aname="_cancelable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"result"), aname="_result", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"progress"), aname="_progress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskReason",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"queueTime"), aname="_queueTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"startTime"), aname="_startTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"completeTime"), aname="_completeTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"eventChainId"), aname="_eventChainId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeTag"), aname="_changeTag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentTaskKey"), aname="_parentTaskKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rootTaskKey"), aname="_rootTaskKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskInfo_Def.__bases__: + bases = list(ns0.TaskInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfTaskInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfTaskInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfTaskInfo_Def.schema + TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"TaskInfo"), aname="_TaskInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._TaskInfo = [] + return + Holder.__name__ = "ArrayOfTaskInfo_Holder" + self.pyclass = Holder + + class CreateCollectorForTasksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateCollectorForTasksRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateCollectorForTasksRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpec",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._filter = None + return + Holder.__name__ = "CreateCollectorForTasksRequestType_Holder" + self.pyclass = Holder + + class CreateTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"taskTypeId"), aname="_taskTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"initiatedBy"), aname="_initiatedBy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelable"), aname="_cancelable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentTaskKey"), aname="_parentTaskKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._obj = None + self._taskTypeId = None + self._initiatedBy = None + self._cancelable = None + self._parentTaskKey = None + return + Holder.__name__ = "CreateTaskRequestType_Holder" + self.pyclass = Holder + + class TaskReason_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskReason") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskReason_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskReason_Def.__bases__: + bases = list(ns0.TaskReason_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskReason_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskReasonSystem_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskReasonSystem") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskReasonSystem_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskReason_Def not in ns0.TaskReasonSystem_Def.__bases__: + bases = list(ns0.TaskReasonSystem_Def.__bases__) + bases.insert(0, ns0.TaskReason_Def) + ns0.TaskReasonSystem_Def.__bases__ = tuple(bases) + + ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskReasonUser_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskReasonUser") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskReasonUser_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskReason_Def not in ns0.TaskReasonUser_Def.__bases__: + bases = list(ns0.TaskReasonUser_Def.__bases__) + bases.insert(0, ns0.TaskReason_Def) + ns0.TaskReasonUser_Def.__bases__ = tuple(bases) + + ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskReasonAlarm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskReasonAlarm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskReasonAlarm_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"alarmName"), aname="_alarmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskReason_Def not in ns0.TaskReasonAlarm_Def.__bases__: + bases = list(ns0.TaskReasonAlarm_Def.__bases__) + bases.insert(0, ns0.TaskReason_Def) + ns0.TaskReasonAlarm_Def.__bases__ = tuple(bases) + + ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskReasonSchedule_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskReasonSchedule") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskReasonSchedule_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskReason_Def not in ns0.TaskReasonSchedule_Def.__bases__: + bases = list(ns0.TaskReasonSchedule_Def.__bases__) + bases.insert(0, ns0.TaskReason_Def) + ns0.TaskReasonSchedule_Def.__bases__ = tuple(bases) + + ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TypeDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TypeDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TypeDescription_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Description_Def not in ns0.TypeDescription_Def.__bases__: + bases = list(ns0.TypeDescription_Def.__bases__) + bases.insert(0, ns0.Description_Def) + ns0.TypeDescription_Def.__bases__ = tuple(bases) + + ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfTypeDescription_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfTypeDescription") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfTypeDescription_Def.schema + TClist = [GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"TypeDescription"), aname="_TypeDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._TypeDescription = [] + return + Holder.__name__ = "ArrayOfTypeDescription_Holder" + self.pyclass = Holder + + class RetrieveUserGroupsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveUserGroupsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveUserGroupsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domain"), aname="_domain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"searchStr"), aname="_searchStr", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"belongsToGroup"), aname="_belongsToGroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"belongsToUser"), aname="_belongsToUser", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"exactMatch"), aname="_exactMatch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"findUsers"), aname="_findUsers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"findGroups"), aname="_findGroups", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._domain = None + self._searchStr = None + self._belongsToGroup = None + self._belongsToUser = None + self._exactMatch = None + self._findUsers = None + self._findGroups = None + return + Holder.__name__ = "RetrieveUserGroupsRequestType_Holder" + self.pyclass = Holder + + class UserSearchResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserSearchResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserSearchResult_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.UserSearchResult_Def.__bases__: + bases = list(ns0.UserSearchResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.UserSearchResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfUserSearchResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfUserSearchResult") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfUserSearchResult_Def.schema + TClist = [GTD("urn:vim25","UserSearchResult",lazy=True)(pname=(ns,"UserSearchResult"), aname="_UserSearchResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._UserSearchResult = [] + return + Holder.__name__ = "ArrayOfUserSearchResult_Holder" + self.pyclass = Holder + + class VirtualAppVAppState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualAppVAppState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualAppSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualAppSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualAppSummary_Def.schema + TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualAppVAppState",lazy=True)(pname=(ns,"vAppState"), aname="_vAppState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ResourcePoolSummary_Def not in ns0.VirtualAppSummary_Def.__bases__: + bases = list(ns0.VirtualAppSummary_Def.__bases__) + bases.insert(0, ns0.ResourcePoolSummary_Def) + ns0.VirtualAppSummary_Def.__bases__ = tuple(bases) + + ns0.ResourcePoolSummary_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateVAppConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateVAppConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateVAppConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "UpdateVAppConfigRequestType_Holder" + self.pyclass = Holder + + class CloneVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CloneVAppRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CloneVAppRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppCloneSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._target = None + self._spec = None + return + Holder.__name__ = "CloneVAppRequestType_Holder" + self.pyclass = Holder + + class ExportVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExportVAppRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExportVAppRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ExportVAppRequestType_Holder" + self.pyclass = Holder + + class PowerOnVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PowerOnVAppRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PowerOnVAppRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "PowerOnVAppRequestType_Holder" + self.pyclass = Holder + + class PowerOffVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PowerOffVAppRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PowerOffVAppRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._force = None + return + Holder.__name__ = "PowerOffVAppRequestType_Holder" + self.pyclass = Holder + + class unregisterVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "unregisterVAppRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.unregisterVAppRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "unregisterVAppRequestType_Holder" + self.pyclass = Holder + + class VirtualDiskType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDiskType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDiskAdapterType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDiskAdapterType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDiskSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskType"), aname="_diskType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapterType"), aname="_adapterType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDiskSpec_Def.__bases__: + bases = list(ns0.VirtualDiskSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDiskSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileBackedVirtualDiskSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileBackedVirtualDiskSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileBackedVirtualDiskSpec_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"capacityKb"), aname="_capacityKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDiskSpec_Def not in ns0.FileBackedVirtualDiskSpec_Def.__bases__: + bases = list(ns0.FileBackedVirtualDiskSpec_Def.__bases__) + bases.insert(0, ns0.VirtualDiskSpec_Def) + ns0.FileBackedVirtualDiskSpec_Def.__bases__ = tuple(bases) + + ns0.VirtualDiskSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceBackedVirtualDiskSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceBackedVirtualDiskSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceBackedVirtualDiskSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDiskSpec_Def not in ns0.DeviceBackedVirtualDiskSpec_Def.__bases__: + bases = list(ns0.DeviceBackedVirtualDiskSpec_Def.__bases__) + bases.insert(0, ns0.VirtualDiskSpec_Def) + ns0.DeviceBackedVirtualDiskSpec_Def.__bases__ = tuple(bases) + + ns0.VirtualDiskSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CreateVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + self._spec = None + return + Holder.__name__ = "CreateVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class DeleteVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DeleteVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DeleteVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "DeleteVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class MoveVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MoveVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MoveVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destDatacenter"), aname="_destDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._sourceName = None + self._sourceDatacenter = None + self._destName = None + self._destDatacenter = None + self._force = None + return + Holder.__name__ = "MoveVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class CopyVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CopyVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CopyVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destDatacenter"), aname="_destDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSpec",lazy=True)(pname=(ns,"destSpec"), aname="_destSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._sourceName = None + self._sourceDatacenter = None + self._destName = None + self._destDatacenter = None + self._destSpec = None + self._force = None + return + Holder.__name__ = "CopyVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class ExtendVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExtendVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExtendVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newCapacityKb"), aname="_newCapacityKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"eagerZero"), aname="_eagerZero", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + self._newCapacityKb = None + self._eagerZero = None + return + Holder.__name__ = "ExtendVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class QueryVirtualDiskFragmentationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVirtualDiskFragmentationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVirtualDiskFragmentationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "QueryVirtualDiskFragmentationRequestType_Holder" + self.pyclass = Holder + + class DefragmentVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DefragmentVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DefragmentVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "DefragmentVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class ShrinkVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ShrinkVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ShrinkVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"copy"), aname="_copy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + self._copy = None + return + Holder.__name__ = "ShrinkVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class InflateVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "InflateVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.InflateVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "InflateVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class EagerZeroVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EagerZeroVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.EagerZeroVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "EagerZeroVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class ZeroFillVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ZeroFillVirtualDiskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ZeroFillVirtualDiskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "ZeroFillVirtualDiskRequestType_Holder" + self.pyclass = Holder + + class SetVirtualDiskUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetVirtualDiskUuidRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetVirtualDiskUuidRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + self._uuid = None + return + Holder.__name__ = "SetVirtualDiskUuidRequestType_Holder" + self.pyclass = Holder + + class QueryVirtualDiskUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVirtualDiskUuidRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVirtualDiskUuidRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "QueryVirtualDiskUuidRequestType_Holder" + self.pyclass = Holder + + class QueryVirtualDiskGeometryRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVirtualDiskGeometryRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVirtualDiskGeometryRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._datacenter = None + return + Holder.__name__ = "QueryVirtualDiskGeometryRequestType_Holder" + self.pyclass = Holder + + class VirtualMachinePowerState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachinePowerState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineConnectionState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineConnectionState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineMovePriority_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineMovePriority") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineMksTicket_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineMksTicket") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineMksTicket_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ticket"), aname="_ticket", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cfgFile"), aname="_cfgFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineMksTicket_Def.__bases__: + bases = list(ns0.VirtualMachineMksTicket_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineMksTicket_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineFaultToleranceState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineFaultToleranceState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineRecordReplayState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineRecordReplayState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineNeedSecondaryReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineNeedSecondaryReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineDisplayTopology_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineDisplayTopology") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineDisplayTopology_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"x"), aname="_x", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"y"), aname="_y", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineDisplayTopology_Def.__bases__: + bases = list(ns0.VirtualMachineDisplayTopology_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineDisplayTopology_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineDisplayTopology_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineDisplayTopology") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineDisplayTopology_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineDisplayTopology",lazy=True)(pname=(ns,"VirtualMachineDisplayTopology"), aname="_VirtualMachineDisplayTopology", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineDisplayTopology = [] + return + Holder.__name__ = "ArrayOfVirtualMachineDisplayTopology_Holder" + self.pyclass = Holder + + class DiskChangeExtent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DiskChangeExtent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DiskChangeExtent_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"start"), aname="_start", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"length"), aname="_length", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DiskChangeExtent_Def.__bases__: + bases = list(ns0.DiskChangeExtent_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DiskChangeExtent_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDiskChangeExtent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDiskChangeExtent") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDiskChangeExtent_Def.schema + TClist = [GTD("urn:vim25","DiskChangeExtent",lazy=True)(pname=(ns,"DiskChangeExtent"), aname="_DiskChangeExtent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DiskChangeExtent = [] + return + Holder.__name__ = "ArrayOfDiskChangeExtent_Holder" + self.pyclass = Holder + + class DiskChangeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DiskChangeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DiskChangeInfo_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"startOffset"), aname="_startOffset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"length"), aname="_length", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DiskChangeExtent",lazy=True)(pname=(ns,"changedArea"), aname="_changedArea", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DiskChangeInfo_Def.__bases__: + bases = list(ns0.DiskChangeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DiskChangeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RefreshStorageInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshStorageInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshStorageInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshStorageInfoRequestType_Holder" + self.pyclass = Holder + + class CreateSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateSnapshotRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateSnapshotRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memory"), aname="_memory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"quiesce"), aname="_quiesce", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._description = None + self._memory = None + self._quiesce = None + return + Holder.__name__ = "CreateSnapshotRequestType_Holder" + self.pyclass = Holder + + class RevertToCurrentSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RevertToCurrentSnapshotRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RevertToCurrentSnapshotRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suppressPowerOn"), aname="_suppressPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._suppressPowerOn = None + return + Holder.__name__ = "RevertToCurrentSnapshotRequestType_Holder" + self.pyclass = Holder + + class RemoveAllSnapshotsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveAllSnapshotsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveAllSnapshotsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RemoveAllSnapshotsRequestType_Holder" + self.pyclass = Holder + + class ReconfigVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "ReconfigVMRequestType_Holder" + self.pyclass = Holder + + class UpgradeVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpgradeVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpgradeVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._version = None + return + Holder.__name__ = "UpgradeVMRequestType_Holder" + self.pyclass = Holder + + class ExtractOvfEnvironmentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExtractOvfEnvironmentRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExtractOvfEnvironmentRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ExtractOvfEnvironmentRequestType_Holder" + self.pyclass = Holder + + class PowerOnVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PowerOnVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PowerOnVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "PowerOnVMRequestType_Holder" + self.pyclass = Holder + + class PowerOffVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PowerOffVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PowerOffVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "PowerOffVMRequestType_Holder" + self.pyclass = Holder + + class SuspendVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SuspendVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SuspendVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "SuspendVMRequestType_Holder" + self.pyclass = Holder + + class ResetVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ResetVMRequestType_Holder" + self.pyclass = Holder + + class ShutdownGuestRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ShutdownGuestRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ShutdownGuestRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ShutdownGuestRequestType_Holder" + self.pyclass = Holder + + class RebootGuestRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RebootGuestRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RebootGuestRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RebootGuestRequestType_Holder" + self.pyclass = Holder + + class StandbyGuestRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StandbyGuestRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StandbyGuestRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "StandbyGuestRequestType_Holder" + self.pyclass = Holder + + class AnswerVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AnswerVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AnswerVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"questionId"), aname="_questionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"answerChoice"), aname="_answerChoice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._questionId = None + self._answerChoice = None + return + Holder.__name__ = "AnswerVMRequestType_Holder" + self.pyclass = Holder + + class CustomizeVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CustomizeVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CustomizeVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "CustomizeVMRequestType_Holder" + self.pyclass = Holder + + class CheckCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckCustomizationSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckCustomizationSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "CheckCustomizationSpecRequestType_Holder" + self.pyclass = Holder + + class MigrateVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MigrateVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MigrateVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMovePriority",lazy=True)(pname=(ns,"priority"), aname="_priority", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._pool = None + self._host = None + self._priority = None + self._state = None + return + Holder.__name__ = "MigrateVMRequestType_Holder" + self.pyclass = Holder + + class RelocateVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RelocateVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RelocateVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMovePriority",lazy=True)(pname=(ns,"priority"), aname="_priority", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + self._priority = None + return + Holder.__name__ = "RelocateVMRequestType_Holder" + self.pyclass = Holder + + class CloneVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CloneVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CloneVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"folder"), aname="_folder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCloneSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._folder = None + self._name = None + self._spec = None + return + Holder.__name__ = "CloneVMRequestType_Holder" + self.pyclass = Holder + + class ExportVmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExportVmRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExportVmRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ExportVmRequestType_Holder" + self.pyclass = Holder + + class MarkAsTemplateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MarkAsTemplateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MarkAsTemplateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "MarkAsTemplateRequestType_Holder" + self.pyclass = Holder + + class MarkAsVirtualMachineRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MarkAsVirtualMachineRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MarkAsVirtualMachineRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._pool = None + self._host = None + return + Holder.__name__ = "MarkAsVirtualMachineRequestType_Holder" + self.pyclass = Holder + + class UnregisterVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UnregisterVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UnregisterVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "UnregisterVMRequestType_Holder" + self.pyclass = Holder + + class ResetGuestInformationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetGuestInformationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetGuestInformationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ResetGuestInformationRequestType_Holder" + self.pyclass = Holder + + class MountToolsInstallerRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MountToolsInstallerRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MountToolsInstallerRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "MountToolsInstallerRequestType_Holder" + self.pyclass = Holder + + class UnmountToolsInstallerRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UnmountToolsInstallerRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UnmountToolsInstallerRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "UnmountToolsInstallerRequestType_Holder" + self.pyclass = Holder + + class UpgradeToolsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpgradeToolsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpgradeToolsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installerOptions"), aname="_installerOptions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._installerOptions = None + return + Holder.__name__ = "UpgradeToolsRequestType_Holder" + self.pyclass = Holder + + class AcquireMksTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AcquireMksTicketRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AcquireMksTicketRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "AcquireMksTicketRequestType_Holder" + self.pyclass = Holder + + class SetScreenResolutionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetScreenResolutionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetScreenResolutionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._width = None + self._height = None + return + Holder.__name__ = "SetScreenResolutionRequestType_Holder" + self.pyclass = Holder + + class DefragmentAllDisksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DefragmentAllDisksRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DefragmentAllDisksRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DefragmentAllDisksRequestType_Holder" + self.pyclass = Holder + + class CreateSecondaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateSecondaryVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateSecondaryVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "CreateSecondaryVMRequestType_Holder" + self.pyclass = Holder + + class TurnOffFaultToleranceForVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "TurnOffFaultToleranceForVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.TurnOffFaultToleranceForVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "TurnOffFaultToleranceForVMRequestType_Holder" + self.pyclass = Holder + + class MakePrimaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MakePrimaryVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.MakePrimaryVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + return + Holder.__name__ = "MakePrimaryVMRequestType_Holder" + self.pyclass = Holder + + class TerminateFaultTolerantVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "TerminateFaultTolerantVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.TerminateFaultTolerantVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + return + Holder.__name__ = "TerminateFaultTolerantVMRequestType_Holder" + self.pyclass = Holder + + class DisableSecondaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DisableSecondaryVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DisableSecondaryVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + return + Holder.__name__ = "DisableSecondaryVMRequestType_Holder" + self.pyclass = Holder + + class EnableSecondaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EnableSecondaryVMRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.EnableSecondaryVMRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + self._host = None + return + Holder.__name__ = "EnableSecondaryVMRequestType_Holder" + self.pyclass = Holder + + class SetDisplayTopologyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetDisplayTopologyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetDisplayTopologyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDisplayTopology",lazy=True)(pname=(ns,"displays"), aname="_displays", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._displays = [] + return + Holder.__name__ = "SetDisplayTopologyRequestType_Holder" + self.pyclass = Holder + + class StartRecordingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StartRecordingRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StartRecordingRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._description = None + return + Holder.__name__ = "StartRecordingRequestType_Holder" + self.pyclass = Holder + + class StopRecordingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StopRecordingRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StopRecordingRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "StopRecordingRequestType_Holder" + self.pyclass = Holder + + class StartReplayingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StartReplayingRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StartReplayingRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"replaySnapshot"), aname="_replaySnapshot", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._replaySnapshot = None + return + Holder.__name__ = "StartReplayingRequestType_Holder" + self.pyclass = Holder + + class StopReplayingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StopReplayingRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StopReplayingRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "StopReplayingRequestType_Holder" + self.pyclass = Holder + + class PromoteDisksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PromoteDisksRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PromoteDisksRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unlink"), aname="_unlink", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDisk",lazy=True)(pname=(ns,"disks"), aname="_disks", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._unlink = None + self._disks = [] + return + Holder.__name__ = "PromoteDisksRequestType_Holder" + self.pyclass = Holder + + class CreateScreenshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateScreenshotRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateScreenshotRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "CreateScreenshotRequestType_Holder" + self.pyclass = Holder + + class QueryChangedDiskAreasRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryChangedDiskAreasRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryChangedDiskAreasRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceKey"), aname="_deviceKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"startOffset"), aname="_startOffset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._snapshot = None + self._deviceKey = None + self._startOffset = None + self._changeId = None + return + Holder.__name__ = "QueryChangedDiskAreasRequestType_Holder" + self.pyclass = Holder + + class QueryUnownedFilesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryUnownedFilesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryUnownedFilesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryUnownedFilesRequestType_Holder" + self.pyclass = Holder + + class ActionParameter_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ActionParameter") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class Action_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Action") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Action_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.Action_Def.__bases__: + bases = list(ns0.Action_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.Action_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MethodActionArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MethodActionArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MethodActionArgument_Def.schema + TClist = [ZSI.TC.AnyType(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.MethodActionArgument_Def.__bases__: + bases = list(ns0.MethodActionArgument_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.MethodActionArgument_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfMethodActionArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfMethodActionArgument") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfMethodActionArgument_Def.schema + TClist = [GTD("urn:vim25","MethodActionArgument",lazy=True)(pname=(ns,"MethodActionArgument"), aname="_MethodActionArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._MethodActionArgument = [] + return + Holder.__name__ = "ArrayOfMethodActionArgument_Holder" + self.pyclass = Holder + + class MethodAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MethodAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MethodAction_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MethodActionArgument",lazy=True)(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Action_Def not in ns0.MethodAction_Def.__bases__: + bases = list(ns0.MethodAction_Def.__bases__) + bases.insert(0, ns0.Action_Def) + ns0.MethodAction_Def.__bases__ = tuple(bases) + + ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SendEmailAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SendEmailAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SendEmailAction_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"toList"), aname="_toList", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ccList"), aname="_ccList", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subject"), aname="_subject", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"body"), aname="_body", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Action_Def not in ns0.SendEmailAction_Def.__bases__: + bases = list(ns0.SendEmailAction_Def.__bases__) + bases.insert(0, ns0.Action_Def) + ns0.SendEmailAction_Def.__bases__ = tuple(bases) + + ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SendSNMPAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SendSNMPAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SendSNMPAction_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Action_Def not in ns0.SendSNMPAction_Def.__bases__: + bases = list(ns0.SendSNMPAction_Def.__bases__) + bases.insert(0, ns0.Action_Def) + ns0.SendSNMPAction_Def.__bases__ = tuple(bases) + + ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RunScriptAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RunScriptAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RunScriptAction_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"script"), aname="_script", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Action_Def not in ns0.RunScriptAction_Def.__bases__: + bases = list(ns0.RunScriptAction_Def.__bases__) + bases.insert(0, ns0.Action_Def) + ns0.RunScriptAction_Def.__bases__ = tuple(bases) + + ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CreateTaskAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CreateTaskAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CreateTaskAction_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"taskTypeId"), aname="_taskTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelable"), aname="_cancelable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Action_Def not in ns0.CreateTaskAction_Def.__bases__: + bases = list(ns0.CreateTaskAction_Def.__bases__) + bases.insert(0, ns0.Action_Def) + ns0.CreateTaskAction_Def.__bases__ = tuple(bases) + + ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RemoveAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveAlarmRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveAlarmRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RemoveAlarmRequestType_Holder" + self.pyclass = Holder + + class ReconfigureAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureAlarmRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureAlarmRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "ReconfigureAlarmRequestType_Holder" + self.pyclass = Holder + + class AlarmAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmAction_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AlarmAction_Def.__bases__: + bases = list(ns0.AlarmAction_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AlarmAction_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfAlarmAction_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAlarmAction") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAlarmAction_Def.schema + TClist = [GTD("urn:vim25","AlarmAction",lazy=True)(pname=(ns,"AlarmAction"), aname="_AlarmAction", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._AlarmAction = [] + return + Holder.__name__ = "ArrayOfAlarmAction_Holder" + self.pyclass = Holder + + class AlarmTriggeringActionTransitionSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmTriggeringActionTransitionSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmTriggeringActionTransitionSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"startState"), aname="_startState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"finalState"), aname="_finalState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"repeats"), aname="_repeats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AlarmTriggeringActionTransitionSpec_Def.__bases__: + bases = list(ns0.AlarmTriggeringActionTransitionSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AlarmTriggeringActionTransitionSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfAlarmTriggeringActionTransitionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAlarmTriggeringActionTransitionSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAlarmTriggeringActionTransitionSpec_Def.schema + TClist = [GTD("urn:vim25","AlarmTriggeringActionTransitionSpec",lazy=True)(pname=(ns,"AlarmTriggeringActionTransitionSpec"), aname="_AlarmTriggeringActionTransitionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._AlarmTriggeringActionTransitionSpec = [] + return + Holder.__name__ = "ArrayOfAlarmTriggeringActionTransitionSpec_Holder" + self.pyclass = Holder + + class AlarmTriggeringAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmTriggeringAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmTriggeringAction_Def.schema + TClist = [GTD("urn:vim25","Action",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmTriggeringActionTransitionSpec",lazy=True)(pname=(ns,"transitionSpecs"), aname="_transitionSpecs", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"green2yellow"), aname="_green2yellow", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"yellow2red"), aname="_yellow2red", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"red2yellow"), aname="_red2yellow", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"yellow2green"), aname="_yellow2green", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmAction_Def not in ns0.AlarmTriggeringAction_Def.__bases__: + bases = list(ns0.AlarmTriggeringAction_Def.__bases__) + bases.insert(0, ns0.AlarmAction_Def) + ns0.AlarmTriggeringAction_Def.__bases__ = tuple(bases) + + ns0.AlarmAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GroupAlarmAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GroupAlarmAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GroupAlarmAction_Def.schema + TClist = [GTD("urn:vim25","AlarmAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmAction_Def not in ns0.GroupAlarmAction_Def.__bases__: + bases = list(ns0.GroupAlarmAction_Def.__bases__) + bases.insert(0, ns0.AlarmAction_Def) + ns0.GroupAlarmAction_Def.__bases__ = tuple(bases) + + ns0.AlarmAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmDescription_Def.schema + TClist = [GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"expr"), aname="_expr", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"stateOperator"), aname="_stateOperator", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"metricOperator"), aname="_metricOperator", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"hostSystemConnectionState"), aname="_hostSystemConnectionState", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"virtualMachinePowerState"), aname="_virtualMachinePowerState", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"datastoreConnectionState"), aname="_datastoreConnectionState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"hostSystemPowerState"), aname="_hostSystemPowerState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"virtualMachineGuestHeartbeatStatus"), aname="_virtualMachineGuestHeartbeatStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"entityStatus"), aname="_entityStatus", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AlarmDescription_Def.__bases__: + bases = list(ns0.AlarmDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AlarmDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmExpression_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AlarmExpression_Def.__bases__: + bases = list(ns0.AlarmExpression_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AlarmExpression_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfAlarmExpression_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAlarmExpression") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAlarmExpression_Def.schema + TClist = [GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"AlarmExpression"), aname="_AlarmExpression", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._AlarmExpression = [] + return + Holder.__name__ = "ArrayOfAlarmExpression_Holder" + self.pyclass = Holder + + class AndAlarmExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AndAlarmExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AndAlarmExpression_Def.schema + TClist = [GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmExpression_Def not in ns0.AndAlarmExpression_Def.__bases__: + bases = list(ns0.AndAlarmExpression_Def.__bases__) + bases.insert(0, ns0.AlarmExpression_Def) + ns0.AndAlarmExpression_Def.__bases__ = tuple(bases) + + ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OrAlarmExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OrAlarmExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OrAlarmExpression_Def.schema + TClist = [GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmExpression_Def not in ns0.OrAlarmExpression_Def.__bases__: + bases = list(ns0.OrAlarmExpression_Def.__bases__) + bases.insert(0, ns0.AlarmExpression_Def) + ns0.OrAlarmExpression_Def.__bases__ = tuple(bases) + + ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class StateAlarmOperator_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StateAlarmOperator") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class StateAlarmExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "StateAlarmExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.StateAlarmExpression_Def.schema + TClist = [GTD("urn:vim25","StateAlarmOperator",lazy=True)(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"statePath"), aname="_statePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"yellow"), aname="_yellow", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"red"), aname="_red", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmExpression_Def not in ns0.StateAlarmExpression_Def.__bases__: + bases = list(ns0.StateAlarmExpression_Def.__bases__) + bases.insert(0, ns0.AlarmExpression_Def) + ns0.StateAlarmExpression_Def.__bases__ = tuple(bases) + + ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EventAlarmExpressionComparisonOperator_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EventAlarmExpressionComparisonOperator") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class EventAlarmExpressionComparison_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventAlarmExpressionComparison") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventAlarmExpressionComparison_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"attributeName"), aname="_attributeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventAlarmExpressionComparison_Def.__bases__: + bases = list(ns0.EventAlarmExpressionComparison_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventAlarmExpressionComparison_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfEventAlarmExpressionComparison_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfEventAlarmExpressionComparison") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfEventAlarmExpressionComparison_Def.schema + TClist = [GTD("urn:vim25","EventAlarmExpressionComparison",lazy=True)(pname=(ns,"EventAlarmExpressionComparison"), aname="_EventAlarmExpressionComparison", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._EventAlarmExpressionComparison = [] + return + Holder.__name__ = "ArrayOfEventAlarmExpressionComparison_Holder" + self.pyclass = Holder + + class EventAlarmExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventAlarmExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventAlarmExpression_Def.schema + TClist = [GTD("urn:vim25","EventAlarmExpressionComparison",lazy=True)(pname=(ns,"comparisons"), aname="_comparisons", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventType"), aname="_eventType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectType"), aname="_objectType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmExpression_Def not in ns0.EventAlarmExpression_Def.__bases__: + bases = list(ns0.EventAlarmExpression_Def.__bases__) + bases.insert(0, ns0.AlarmExpression_Def) + ns0.EventAlarmExpression_Def.__bases__ = tuple(bases) + + ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MetricAlarmOperator_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MetricAlarmOperator") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class MetricAlarmExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MetricAlarmExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MetricAlarmExpression_Def.schema + TClist = [GTD("urn:vim25","MetricAlarmOperator",lazy=True)(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"metric"), aname="_metric", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"yellow"), aname="_yellow", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"yellowInterval"), aname="_yellowInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"red"), aname="_red", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"redInterval"), aname="_redInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmExpression_Def not in ns0.MetricAlarmExpression_Def.__bases__: + bases = list(ns0.MetricAlarmExpression_Def.__bases__) + bases.insert(0, ns0.AlarmExpression_Def) + ns0.MetricAlarmExpression_Def.__bases__ = tuple(bases) + + ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModifiedTime"), aname="_lastModifiedTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lastModifiedUser"), aname="_lastModifiedUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"creationEventId"), aname="_creationEventId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmSpec_Def not in ns0.AlarmInfo_Def.__bases__: + bases = list(ns0.AlarmInfo_Def.__bases__) + bases.insert(0, ns0.AlarmSpec_Def) + ns0.AlarmInfo_Def.__bases__ = tuple(bases) + + ns0.AlarmSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CreateAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateAlarmRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateAlarmRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._spec = None + return + Holder.__name__ = "CreateAlarmRequestType_Holder" + self.pyclass = Holder + + class GetAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "GetAlarmRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.GetAlarmRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + return + Holder.__name__ = "GetAlarmRequestType_Holder" + self.pyclass = Holder + + class GetAlarmActionsEnabledRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "GetAlarmActionsEnabledRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.GetAlarmActionsEnabledRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + return + Holder.__name__ = "GetAlarmActionsEnabledRequestType_Holder" + self.pyclass = Holder + + class SetAlarmActionsEnabledRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetAlarmActionsEnabledRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetAlarmActionsEnabledRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._enabled = None + return + Holder.__name__ = "SetAlarmActionsEnabledRequestType_Holder" + self.pyclass = Holder + + class GetAlarmStateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "GetAlarmStateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.GetAlarmStateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + return + Holder.__name__ = "GetAlarmStateRequestType_Holder" + self.pyclass = Holder + + class AcknowledgeAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AcknowledgeAlarmRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AcknowledgeAlarmRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._alarm = None + self._entity = None + return + Holder.__name__ = "AcknowledgeAlarmRequestType_Holder" + self.pyclass = Holder + + class AlarmSetting_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmSetting") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmSetting_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"toleranceRange"), aname="_toleranceRange", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"reportingFrequency"), aname="_reportingFrequency", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AlarmSetting_Def.__bases__: + bases = list(ns0.AlarmSetting_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AlarmSetting_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"actionFrequency"), aname="_actionFrequency", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmSetting",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AlarmSpec_Def.__bases__: + bases = list(ns0.AlarmSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AlarmSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmState_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmState") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmState_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"acknowledged"), aname="_acknowledged", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"acknowledgedByUser"), aname="_acknowledgedByUser", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"acknowledgedTime"), aname="_acknowledgedTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AlarmState_Def.__bases__: + bases = list(ns0.AlarmState_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AlarmState_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfAlarmState_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAlarmState") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAlarmState_Def.schema + TClist = [GTD("urn:vim25","AlarmState",lazy=True)(pname=(ns,"AlarmState"), aname="_AlarmState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._AlarmState = [] + return + Holder.__name__ = "ArrayOfAlarmState_Holder" + self.pyclass = Holder + + class ActionType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ActionType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterAction_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterAction_Def.__bases__: + bases = list(ns0.ClusterAction_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterAction_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterAction_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterAction") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterAction_Def.schema + TClist = [GTD("urn:vim25","ClusterAction",lazy=True)(pname=(ns,"ClusterAction"), aname="_ClusterAction", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterAction = [] + return + Holder.__name__ = "ArrayOfClusterAction_Holder" + self.pyclass = Holder + + class ClusterActionHistory_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterActionHistory") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterActionHistory_Def.schema + TClist = [GTD("urn:vim25","ClusterAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterActionHistory_Def.__bases__: + bases = list(ns0.ClusterActionHistory_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterActionHistory_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterActionHistory_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterActionHistory") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterActionHistory_Def.schema + TClist = [GTD("urn:vim25","ClusterActionHistory",lazy=True)(pname=(ns,"ClusterActionHistory"), aname="_ClusterActionHistory", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterActionHistory = [] + return + Holder.__name__ = "ArrayOfClusterActionHistory_Holder" + self.pyclass = Holder + + class ClusterAffinityRuleSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterAffinityRuleSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterAffinityRuleSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterRuleInfo_Def not in ns0.ClusterAffinityRuleSpec_Def.__bases__: + bases = list(ns0.ClusterAffinityRuleSpec_Def.__bases__) + bases.insert(0, ns0.ClusterRuleInfo_Def) + ns0.ClusterAffinityRuleSpec_Def.__bases__ = tuple(bases) + + ns0.ClusterRuleInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterAntiAffinityRuleSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterAntiAffinityRuleSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterAntiAffinityRuleSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterRuleInfo_Def not in ns0.ClusterAntiAffinityRuleSpec_Def.__bases__: + bases = list(ns0.ClusterAntiAffinityRuleSpec_Def.__bases__) + bases.insert(0, ns0.ClusterRuleInfo_Def) + ns0.ClusterAntiAffinityRuleSpec_Def.__bases__ = tuple(bases) + + ns0.ClusterRuleInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterAttemptedVmInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterAttemptedVmInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterAttemptedVmInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"task"), aname="_task", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterAttemptedVmInfo_Def.__bases__: + bases = list(ns0.ClusterAttemptedVmInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterAttemptedVmInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterAttemptedVmInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterAttemptedVmInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterAttemptedVmInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterAttemptedVmInfo",lazy=True)(pname=(ns,"ClusterAttemptedVmInfo"), aname="_ClusterAttemptedVmInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterAttemptedVmInfo = [] + return + Holder.__name__ = "ArrayOfClusterAttemptedVmInfo_Holder" + self.pyclass = Holder + + class ClusterConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"dasVmConfig"), aname="_dasVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"drsVmConfig"), aname="_drsVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterConfigInfo_Def.__bases__: + bases = list(ns0.ClusterConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsBehavior_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DrsBehavior") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDrsConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDrsConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDrsConfigInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enableVmBehaviorOverrides"), aname="_enableVmBehaviorOverrides", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DrsBehavior",lazy=True)(pname=(ns,"defaultVmBehavior"), aname="_defaultVmBehavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vmotionRate"), aname="_vmotionRate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDrsConfigInfo_Def.__bases__: + bases = list(ns0.ClusterDrsConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDrsConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDrsVmConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDrsVmConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDrsVmConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DrsBehavior",lazy=True)(pname=(ns,"behavior"), aname="_behavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDrsVmConfigInfo_Def.__bases__: + bases = list(ns0.ClusterDrsVmConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDrsVmConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDrsVmConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDrsVmConfigInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDrsVmConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"ClusterDrsVmConfigInfo"), aname="_ClusterDrsVmConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDrsVmConfigInfo = [] + return + Holder.__name__ = "ArrayOfClusterDrsVmConfigInfo_Holder" + self.pyclass = Holder + + class ClusterConfigInfoEx_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterConfigInfoEx") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterConfigInfoEx_Def.schema + TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"dasVmConfig"), aname="_dasVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"drsVmConfig"), aname="_drsVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmConfigInfo",lazy=True)(pname=(ns,"dpmConfigInfo"), aname="_dpmConfigInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmHostConfigInfo",lazy=True)(pname=(ns,"dpmHostConfig"), aname="_dpmHostConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ComputeResourceConfigInfo_Def not in ns0.ClusterConfigInfoEx_Def.__bases__: + bases = list(ns0.ClusterConfigInfoEx_Def.__bases__) + bases.insert(0, ns0.ComputeResourceConfigInfo_Def) + ns0.ClusterConfigInfoEx_Def.__bases__ = tuple(bases) + + ns0.ComputeResourceConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DpmBehavior_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DpmBehavior") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDpmConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDpmConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDpmConfigInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DpmBehavior",lazy=True)(pname=(ns,"defaultDpmBehavior"), aname="_defaultDpmBehavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostPowerActionRate"), aname="_hostPowerActionRate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDpmConfigInfo_Def.__bases__: + bases = list(ns0.ClusterDpmConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDpmConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDpmHostConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDpmHostConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDpmHostConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DpmBehavior",lazy=True)(pname=(ns,"behavior"), aname="_behavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDpmHostConfigInfo_Def.__bases__: + bases = list(ns0.ClusterDpmHostConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDpmHostConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDpmHostConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDpmHostConfigInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDpmHostConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterDpmHostConfigInfo",lazy=True)(pname=(ns,"ClusterDpmHostConfigInfo"), aname="_ClusterDpmHostConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDpmHostConfigInfo = [] + return + Holder.__name__ = "ArrayOfClusterDpmHostConfigInfo_Holder" + self.pyclass = Holder + + class ClusterConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigSpec",lazy=True)(pname=(ns,"dasVmConfigSpec"), aname="_dasVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigSpec",lazy=True)(pname=(ns,"drsVmConfigSpec"), aname="_drsVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleSpec",lazy=True)(pname=(ns,"rulesSpec"), aname="_rulesSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterConfigSpec_Def.__bases__: + bases = list(ns0.ClusterConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasVmConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasVmConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasVmConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.ClusterDasVmConfigSpec_Def.__bases__: + bases = list(ns0.ClusterDasVmConfigSpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.ClusterDasVmConfigSpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDasVmConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDasVmConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDasVmConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterDasVmConfigSpec",lazy=True)(pname=(ns,"ClusterDasVmConfigSpec"), aname="_ClusterDasVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDasVmConfigSpec = [] + return + Holder.__name__ = "ArrayOfClusterDasVmConfigSpec_Holder" + self.pyclass = Holder + + class ClusterDrsVmConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDrsVmConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDrsVmConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.ClusterDrsVmConfigSpec_Def.__bases__: + bases = list(ns0.ClusterDrsVmConfigSpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.ClusterDrsVmConfigSpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDrsVmConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDrsVmConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDrsVmConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsVmConfigSpec",lazy=True)(pname=(ns,"ClusterDrsVmConfigSpec"), aname="_ClusterDrsVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDrsVmConfigSpec = [] + return + Holder.__name__ = "ArrayOfClusterDrsVmConfigSpec_Holder" + self.pyclass = Holder + + class ClusterRuleSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterRuleSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterRuleSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.ClusterRuleSpec_Def.__bases__: + bases = list(ns0.ClusterRuleSpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.ClusterRuleSpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterRuleSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterRuleSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterRuleSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterRuleSpec",lazy=True)(pname=(ns,"ClusterRuleSpec"), aname="_ClusterRuleSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterRuleSpec = [] + return + Holder.__name__ = "ArrayOfClusterRuleSpec_Holder" + self.pyclass = Holder + + class ClusterConfigSpecEx_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterConfigSpecEx") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterConfigSpecEx_Def.schema + TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigSpec",lazy=True)(pname=(ns,"dasVmConfigSpec"), aname="_dasVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigSpec",lazy=True)(pname=(ns,"drsVmConfigSpec"), aname="_drsVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleSpec",lazy=True)(pname=(ns,"rulesSpec"), aname="_rulesSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmConfigInfo",lazy=True)(pname=(ns,"dpmConfig"), aname="_dpmConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmHostConfigSpec",lazy=True)(pname=(ns,"dpmHostConfigSpec"), aname="_dpmHostConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ComputeResourceConfigSpec_Def not in ns0.ClusterConfigSpecEx_Def.__bases__: + bases = list(ns0.ClusterConfigSpecEx_Def.__bases__) + bases.insert(0, ns0.ComputeResourceConfigSpec_Def) + ns0.ClusterConfigSpecEx_Def.__bases__ = tuple(bases) + + ns0.ComputeResourceConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDpmHostConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDpmHostConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDpmHostConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterDpmHostConfigInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.ClusterDpmHostConfigSpec_Def.__bases__: + bases = list(ns0.ClusterDpmHostConfigSpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.ClusterDpmHostConfigSpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDpmHostConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDpmHostConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDpmHostConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ClusterDpmHostConfigSpec",lazy=True)(pname=(ns,"ClusterDpmHostConfigSpec"), aname="_ClusterDpmHostConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDpmHostConfigSpec = [] + return + Holder.__name__ = "ArrayOfClusterDpmHostConfigSpec_Holder" + self.pyclass = Holder + + class ClusterDasAamHostInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasAamHostInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasAamHostInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterDasAamNodeState",lazy=True)(pname=(ns,"hostDasState"), aname="_hostDasState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"primaryHosts"), aname="_primaryHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasHostInfo_Def not in ns0.ClusterDasAamHostInfo_Def.__bases__: + bases = list(ns0.ClusterDasAamHostInfo_Def.__bases__) + bases.insert(0, ns0.ClusterDasHostInfo_Def) + ns0.ClusterDasAamHostInfo_Def.__bases__ = tuple(bases) + + ns0.ClusterDasHostInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasAamNodeStateDasState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ClusterDasAamNodeStateDasState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDasAamNodeState_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasAamNodeState") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasAamNodeState_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configState"), aname="_configState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"runtimeState"), aname="_runtimeState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasAamNodeState_Def.__bases__: + bases = list(ns0.ClusterDasAamNodeState_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasAamNodeState_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDasAamNodeState_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDasAamNodeState") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDasAamNodeState_Def.schema + TClist = [GTD("urn:vim25","ClusterDasAamNodeState",lazy=True)(pname=(ns,"ClusterDasAamNodeState"), aname="_ClusterDasAamNodeState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDasAamNodeState = [] + return + Holder.__name__ = "ArrayOfClusterDasAamNodeState_Holder" + self.pyclass = Holder + + class ClusterDasAdmissionControlInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasAdmissionControlInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasAdmissionControlInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasAdmissionControlInfo_Def.__bases__: + bases = list(ns0.ClusterDasAdmissionControlInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasAdmissionControlInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasAdmissionControlPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasAdmissionControlPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasAdmissionControlPolicy_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasAdmissionControlPolicy_Def.__bases__: + bases = list(ns0.ClusterDasAdmissionControlPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasAdmissionControlPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasAdvancedRuntimeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasAdvancedRuntimeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasAdvancedRuntimeInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterDasHostInfo",lazy=True)(pname=(ns,"dasHostInfo"), aname="_dasHostInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasAdvancedRuntimeInfo_Def.__bases__: + bases = list(ns0.ClusterDasAdvancedRuntimeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasAdvancedRuntimeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasConfigInfoServiceState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ClusterDasConfigInfoServiceState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDasConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasConfigInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmMonitoring"), aname="_vmMonitoring", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostMonitoring"), aname="_hostMonitoring", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"failoverLevel"), aname="_failoverLevel", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasAdmissionControlPolicy",lazy=True)(pname=(ns,"admissionControlPolicy"), aname="_admissionControlPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"admissionControlEnabled"), aname="_admissionControlEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmSettings",lazy=True)(pname=(ns,"defaultVmSettings"), aname="_defaultVmSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasConfigInfo_Def.__bases__: + bases = list(ns0.ClusterDasConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numVcpus"), aname="_numVcpus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuMHz"), aname="_cpuMHz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.__bases__: + bases = list(ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"slots"), aname="_slots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.__bases__: + bases = list(ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.schema + TClist = [GTD("urn:vim25","ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots",lazy=True)(pname=(ns,"ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots"), aname="_ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots = [] + return + Holder.__name__ = "ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Holder" + self.pyclass = Holder + + class ClusterDasFailoverLevelAdvancedRuntimeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasFailoverLevelAdvancedRuntimeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo",lazy=True)(pname=(ns,"slotInfo"), aname="_slotInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalSlots"), aname="_totalSlots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"usedSlots"), aname="_usedSlots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"unreservedSlots"), aname="_unreservedSlots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalVms"), aname="_totalVms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalHosts"), aname="_totalHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalGoodHosts"), aname="_totalGoodHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots",lazy=True)(pname=(ns,"hostSlots"), aname="_hostSlots", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasAdvancedRuntimeInfo_Def not in ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.__bases__: + bases = list(ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.__bases__) + bases.insert(0, ns0.ClusterDasAdvancedRuntimeInfo_Def) + ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.__bases__ = tuple(bases) + + ns0.ClusterDasAdvancedRuntimeInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasHostInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasHostInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasHostInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasHostInfo_Def.__bases__: + bases = list(ns0.ClusterDasHostInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasHostInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDasHostRecommendation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasHostRecommendation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasHostRecommendation_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"drsRating"), aname="_drsRating", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasHostRecommendation_Def.__bases__: + bases = list(ns0.ClusterDasHostRecommendation_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasHostRecommendation_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasVmPriority_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DasVmPriority") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDasVmConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasVmConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasVmConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DasVmPriority",lazy=True)(pname=(ns,"restartPriority"), aname="_restartPriority", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"powerOffOnIsolation"), aname="_powerOffOnIsolation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmSettings",lazy=True)(pname=(ns,"dasSettings"), aname="_dasSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasVmConfigInfo_Def.__bases__: + bases = list(ns0.ClusterDasVmConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasVmConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDasVmConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDasVmConfigInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDasVmConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"ClusterDasVmConfigInfo"), aname="_ClusterDasVmConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDasVmConfigInfo = [] + return + Holder.__name__ = "ArrayOfClusterDasVmConfigInfo_Holder" + self.pyclass = Holder + + class ClusterDasVmSettingsRestartPriority_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ClusterDasVmSettingsRestartPriority") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDasVmSettingsIsolationResponse_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ClusterDasVmSettingsIsolationResponse") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDasVmSettings_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDasVmSettings") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDasVmSettings_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"restartPriority"), aname="_restartPriority", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"isolationResponse"), aname="_isolationResponse", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterVmToolsMonitoringSettings",lazy=True)(pname=(ns,"vmToolsMonitoringSettings"), aname="_vmToolsMonitoringSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDasVmSettings_Def.__bases__: + bases = list(ns0.ClusterDasVmSettings_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDasVmSettings_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDrsFaultsFaultsByVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDrsFaultsFaultsByVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDrsFaultsFaultsByVm_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDrsFaultsFaultsByVm_Def.__bases__: + bases = list(ns0.ClusterDrsFaultsFaultsByVm_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDrsFaultsFaultsByVm_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDrsFaultsFaultsByVm_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDrsFaultsFaultsByVm") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDrsFaultsFaultsByVm_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsFaultsFaultsByVm",lazy=True)(pname=(ns,"ClusterDrsFaultsFaultsByVm"), aname="_ClusterDrsFaultsFaultsByVm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDrsFaultsFaultsByVm = [] + return + Holder.__name__ = "ArrayOfClusterDrsFaultsFaultsByVm_Holder" + self.pyclass = Holder + + class ClusterDrsFaults_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDrsFaults") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDrsFaults_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsFaultsFaultsByVm",lazy=True)(pname=(ns,"faultsByVm"), aname="_faultsByVm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDrsFaults_Def.__bases__: + bases = list(ns0.ClusterDrsFaults_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDrsFaults_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDrsFaults_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDrsFaults") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDrsFaults_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsFaults",lazy=True)(pname=(ns,"ClusterDrsFaults"), aname="_ClusterDrsFaults", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDrsFaults = [] + return + Holder.__name__ = "ArrayOfClusterDrsFaults_Holder" + self.pyclass = Holder + + class ClusterDrsMigration_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDrsMigration") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDrsMigration_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuLoad"), aname="_cpuLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryLoad"), aname="_memoryLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"sourceCpuLoad"), aname="_sourceCpuLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"sourceMemoryLoad"), aname="_sourceMemoryLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destination"), aname="_destination", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"destinationCpuLoad"), aname="_destinationCpuLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"destinationMemoryLoad"), aname="_destinationMemoryLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDrsMigration_Def.__bases__: + bases = list(ns0.ClusterDrsMigration_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDrsMigration_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDrsMigration_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDrsMigration") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDrsMigration_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsMigration",lazy=True)(pname=(ns,"ClusterDrsMigration"), aname="_ClusterDrsMigration", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDrsMigration = [] + return + Holder.__name__ = "ArrayOfClusterDrsMigration_Holder" + self.pyclass = Holder + + class DrsRecommendationReasonCode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DrsRecommendationReasonCode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterDrsRecommendation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDrsRecommendation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDrsRecommendation_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"rating"), aname="_rating", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reasonText"), aname="_reasonText", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsMigration",lazy=True)(pname=(ns,"migrationList"), aname="_migrationList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterDrsRecommendation_Def.__bases__: + bases = list(ns0.ClusterDrsRecommendation_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterDrsRecommendation_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterDrsRecommendation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterDrsRecommendation") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterDrsRecommendation_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsRecommendation",lazy=True)(pname=(ns,"ClusterDrsRecommendation"), aname="_ClusterDrsRecommendation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterDrsRecommendation = [] + return + Holder.__name__ = "ArrayOfClusterDrsRecommendation_Holder" + self.pyclass = Holder + + class ClusterFailoverHostAdmissionControlInfoHostStatus_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterFailoverHostAdmissionControlInfoHostStatus") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.__bases__: + bases = list(ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus_Def.schema + TClist = [GTD("urn:vim25","ClusterFailoverHostAdmissionControlInfoHostStatus",lazy=True)(pname=(ns,"ClusterFailoverHostAdmissionControlInfoHostStatus"), aname="_ClusterFailoverHostAdmissionControlInfoHostStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterFailoverHostAdmissionControlInfoHostStatus = [] + return + Holder.__name__ = "ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus_Holder" + self.pyclass = Holder + + class ClusterFailoverHostAdmissionControlInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterFailoverHostAdmissionControlInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterFailoverHostAdmissionControlInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterFailoverHostAdmissionControlInfoHostStatus",lazy=True)(pname=(ns,"hostStatus"), aname="_hostStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasAdmissionControlInfo_Def not in ns0.ClusterFailoverHostAdmissionControlInfo_Def.__bases__: + bases = list(ns0.ClusterFailoverHostAdmissionControlInfo_Def.__bases__) + bases.insert(0, ns0.ClusterDasAdmissionControlInfo_Def) + ns0.ClusterFailoverHostAdmissionControlInfo_Def.__bases__ = tuple(bases) + + ns0.ClusterDasAdmissionControlInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterFailoverHostAdmissionControlPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterFailoverHostAdmissionControlPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterFailoverHostAdmissionControlPolicy_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"failoverHosts"), aname="_failoverHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasAdmissionControlPolicy_Def not in ns0.ClusterFailoverHostAdmissionControlPolicy_Def.__bases__: + bases = list(ns0.ClusterFailoverHostAdmissionControlPolicy_Def.__bases__) + bases.insert(0, ns0.ClusterDasAdmissionControlPolicy_Def) + ns0.ClusterFailoverHostAdmissionControlPolicy_Def.__bases__ = tuple(bases) + + ns0.ClusterDasAdmissionControlPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterFailoverLevelAdmissionControlInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterFailoverLevelAdmissionControlInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterFailoverLevelAdmissionControlInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"currentFailoverLevel"), aname="_currentFailoverLevel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasAdmissionControlInfo_Def not in ns0.ClusterFailoverLevelAdmissionControlInfo_Def.__bases__: + bases = list(ns0.ClusterFailoverLevelAdmissionControlInfo_Def.__bases__) + bases.insert(0, ns0.ClusterDasAdmissionControlInfo_Def) + ns0.ClusterFailoverLevelAdmissionControlInfo_Def.__bases__ = tuple(bases) + + ns0.ClusterDasAdmissionControlInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterFailoverLevelAdmissionControlPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterFailoverLevelAdmissionControlPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"failoverLevel"), aname="_failoverLevel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasAdmissionControlPolicy_Def not in ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.__bases__: + bases = list(ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.__bases__) + bases.insert(0, ns0.ClusterDasAdmissionControlPolicy_Def) + ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.__bases__ = tuple(bases) + + ns0.ClusterDasAdmissionControlPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterFailoverResourcesAdmissionControlInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterFailoverResourcesAdmissionControlInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"currentCpuFailoverResourcesPercent"), aname="_currentCpuFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"currentMemoryFailoverResourcesPercent"), aname="_currentMemoryFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasAdmissionControlInfo_Def not in ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.__bases__: + bases = list(ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.__bases__) + bases.insert(0, ns0.ClusterDasAdmissionControlInfo_Def) + ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.__bases__ = tuple(bases) + + ns0.ClusterDasAdmissionControlInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterFailoverResourcesAdmissionControlPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterFailoverResourcesAdmissionControlPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"cpuFailoverResourcesPercent"), aname="_cpuFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryFailoverResourcesPercent"), aname="_memoryFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterDasAdmissionControlPolicy_Def not in ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.__bases__: + bases = list(ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.__bases__) + bases.insert(0, ns0.ClusterDasAdmissionControlPolicy_Def) + ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.__bases__ = tuple(bases) + + ns0.ClusterDasAdmissionControlPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostPowerOperationType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostPowerOperationType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterHostPowerAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterHostPowerAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterHostPowerAction_Def.schema + TClist = [GTD("urn:vim25","HostPowerOperationType",lazy=True)(pname=(ns,"operationType"), aname="_operationType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"powerConsumptionWatt"), aname="_powerConsumptionWatt", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuCapacityMHz"), aname="_cpuCapacityMHz", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memCapacityMB"), aname="_memCapacityMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterAction_Def not in ns0.ClusterHostPowerAction_Def.__bases__: + bases = list(ns0.ClusterHostPowerAction_Def.__bases__) + bases.insert(0, ns0.ClusterAction_Def) + ns0.ClusterHostPowerAction_Def.__bases__ = tuple(bases) + + ns0.ClusterAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterHostRecommendation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterHostRecommendation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterHostRecommendation_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"rating"), aname="_rating", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterHostRecommendation_Def.__bases__: + bases = list(ns0.ClusterHostRecommendation_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterHostRecommendation_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterHostRecommendation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterHostRecommendation") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterHostRecommendation_Def.schema + TClist = [GTD("urn:vim25","ClusterHostRecommendation",lazy=True)(pname=(ns,"ClusterHostRecommendation"), aname="_ClusterHostRecommendation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterHostRecommendation = [] + return + Holder.__name__ = "ArrayOfClusterHostRecommendation_Holder" + self.pyclass = Holder + + class ClusterInitialPlacementAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterInitialPlacementAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterInitialPlacementAction_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"targetHost"), aname="_targetHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterAction_Def not in ns0.ClusterInitialPlacementAction_Def.__bases__: + bases = list(ns0.ClusterInitialPlacementAction_Def.__bases__) + bases.insert(0, ns0.ClusterAction_Def) + ns0.ClusterInitialPlacementAction_Def.__bases__ = tuple(bases) + + ns0.ClusterAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterMigrationAction_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterMigrationAction") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterMigrationAction_Def.schema + TClist = [GTD("urn:vim25","ClusterDrsMigration",lazy=True)(pname=(ns,"drsMigration"), aname="_drsMigration", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterAction_Def not in ns0.ClusterMigrationAction_Def.__bases__: + bases = list(ns0.ClusterMigrationAction_Def.__bases__) + bases.insert(0, ns0.ClusterAction_Def) + ns0.ClusterMigrationAction_Def.__bases__ = tuple(bases) + + ns0.ClusterAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterNotAttemptedVmInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterNotAttemptedVmInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterNotAttemptedVmInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterNotAttemptedVmInfo_Def.__bases__: + bases = list(ns0.ClusterNotAttemptedVmInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterNotAttemptedVmInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterNotAttemptedVmInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterNotAttemptedVmInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterNotAttemptedVmInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterNotAttemptedVmInfo",lazy=True)(pname=(ns,"ClusterNotAttemptedVmInfo"), aname="_ClusterNotAttemptedVmInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterNotAttemptedVmInfo = [] + return + Holder.__name__ = "ArrayOfClusterNotAttemptedVmInfo_Holder" + self.pyclass = Holder + + class ClusterPowerOnVmResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterPowerOnVmResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterPowerOnVmResult_Def.schema + TClist = [GTD("urn:vim25","ClusterAttemptedVmInfo",lazy=True)(pname=(ns,"attempted"), aname="_attempted", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterNotAttemptedVmInfo",lazy=True)(pname=(ns,"notAttempted"), aname="_notAttempted", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRecommendation",lazy=True)(pname=(ns,"recommendations"), aname="_recommendations", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterPowerOnVmResult_Def.__bases__: + bases = list(ns0.ClusterPowerOnVmResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterPowerOnVmResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RecommendationType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RecommendationType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class RecommendationReasonCode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RecommendationReasonCode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterRecommendation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterRecommendation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterRecommendation_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"rating"), aname="_rating", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reasonText"), aname="_reasonText", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"prerequisite"), aname="_prerequisite", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterRecommendation_Def.__bases__: + bases = list(ns0.ClusterRecommendation_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterRecommendation_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterRecommendation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterRecommendation") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterRecommendation_Def.schema + TClist = [GTD("urn:vim25","ClusterRecommendation",lazy=True)(pname=(ns,"ClusterRecommendation"), aname="_ClusterRecommendation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterRecommendation = [] + return + Holder.__name__ = "ArrayOfClusterRecommendation_Holder" + self.pyclass = Holder + + class ClusterRuleInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterRuleInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterRuleInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterRuleInfo_Def.__bases__: + bases = list(ns0.ClusterRuleInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterRuleInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfClusterRuleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfClusterRuleInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfClusterRuleInfo_Def.schema + TClist = [GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"ClusterRuleInfo"), aname="_ClusterRuleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ClusterRuleInfo = [] + return + Holder.__name__ = "ArrayOfClusterRuleInfo_Holder" + self.pyclass = Holder + + class ClusterVmToolsMonitoringSettings_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterVmToolsMonitoringSettings") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterVmToolsMonitoringSettings_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"clusterSettings"), aname="_clusterSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"failureInterval"), aname="_failureInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"minUpTime"), aname="_minUpTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxFailures"), aname="_maxFailures", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxFailureWindow"), aname="_maxFailureWindow", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ClusterVmToolsMonitoringSettings_Def.__bases__: + bases = list(ns0.ClusterVmToolsMonitoringSettings_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ClusterVmToolsMonitoringSettings_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortConfigSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortConfigSpec_Def.__bases__: + bases = list(ns0.DVPortConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDVPortConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDVPortConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDVPortConfigSpec_Def.schema + TClist = [GTD("urn:vim25","DVPortConfigSpec",lazy=True)(pname=(ns,"DVPortConfigSpec"), aname="_DVPortConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DVPortConfigSpec = [] + return + Holder.__name__ = "ArrayOfDVPortConfigSpec_Holder" + self.pyclass = Holder + + class DVPortConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortConfigInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortConfigInfo_Def.__bases__: + bases = list(ns0.DVPortConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSTrafficShapingPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSTrafficShapingPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSTrafficShapingPolicy_Def.schema + TClist = [GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongPolicy",lazy=True)(pname=(ns,"averageBandwidth"), aname="_averageBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongPolicy",lazy=True)(pname=(ns,"peakBandwidth"), aname="_peakBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongPolicy",lazy=True)(pname=(ns,"burstSize"), aname="_burstSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.DVSTrafficShapingPolicy_Def.__bases__: + bases = list(ns0.DVSTrafficShapingPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.DVSTrafficShapingPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSVendorSpecificConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSVendorSpecificConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSVendorSpecificConfig_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"keyValue"), aname="_keyValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.DVSVendorSpecificConfig_Def.__bases__: + bases = list(ns0.DVSVendorSpecificConfig_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.DVSVendorSpecificConfig_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortSetting_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortSetting") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortSetting_Def.schema + TClist = [GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"blocked"), aname="_blocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSTrafficShapingPolicy",lazy=True)(pname=(ns,"inShapingPolicy"), aname="_inShapingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSTrafficShapingPolicy",lazy=True)(pname=(ns,"outShapingPolicy"), aname="_outShapingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSVendorSpecificConfig",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortSetting_Def.__bases__: + bases = list(ns0.DVPortSetting_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortSetting_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortStatus_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortStatus") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortStatus_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"linkUp"), aname="_linkUp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"blocked"), aname="_blocked", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NumericRange",lazy=True)(pname=(ns,"vlanIds"), aname="_vlanIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"trunkingMode"), aname="_trunkingMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"linkPeer"), aname="_linkPeer", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortStatus_Def.__bases__: + bases = list(ns0.DVPortStatus_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortStatus_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortState_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortState") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortState_Def.schema + TClist = [GTD("urn:vim25","DVPortStatus",lazy=True)(pname=(ns,"runtimeInfo"), aname="_runtimeInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortStatistics",lazy=True)(pname=(ns,"stats"), aname="_stats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificState"), aname="_vendorSpecificState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortState_Def.__bases__: + bases = list(ns0.DVPortState_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortState_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualPort_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualPort") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualPort_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortConfigInfo",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dvsUuid"), aname="_dvsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"proxyHost"), aname="_proxyHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnectee",lazy=True)(pname=(ns,"connectee"), aname="_connectee", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"conflict"), aname="_conflict", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"conflictPortKey"), aname="_conflictPortKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"connectionCookie"), aname="_connectionCookie", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastStatusChange"), aname="_lastStatusChange", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualPort_Def.__bases__: + bases = list(ns0.DistributedVirtualPort_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualPort_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualPort_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualPort") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualPort_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualPort",lazy=True)(pname=(ns,"DistributedVirtualPort"), aname="_DistributedVirtualPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualPort = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualPort_Holder" + self.pyclass = Holder + + class DistributedVirtualPortgroupPortgroupType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DistributedVirtualPortgroupPortgroupType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DVPortgroupPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupPolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"blockOverrideAllowed"), aname="_blockOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shapingOverrideAllowed"), aname="_shapingOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vendorConfigOverrideAllowed"), aname="_vendorConfigOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"livePortMovingAllowed"), aname="_livePortMovingAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"portConfigResetAtDisconnect"), aname="_portConfigResetAtDisconnect", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortgroupPolicy_Def.__bases__: + bases = list(ns0.DVPortgroupPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortgroupPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualPortgroupMetaTagName_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DistributedVirtualPortgroupMetaTagName") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DVPortgroupConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupConfigSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portNameFormat"), aname="_portNameFormat", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortgroupConfigSpec_Def.__bases__: + bases = list(ns0.DVPortgroupConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortgroupConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDVPortgroupConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDVPortgroupConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDVPortgroupConfigSpec_Def.schema + TClist = [GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"DVPortgroupConfigSpec"), aname="_DVPortgroupConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DVPortgroupConfigSpec = [] + return + Holder.__name__ = "ArrayOfDVPortgroupConfigSpec_Holder" + self.pyclass = Holder + + class DVPortgroupConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupConfigInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portNameFormat"), aname="_portNameFormat", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVPortgroupConfigInfo_Def.__bases__: + bases = list(ns0.DVPortgroupConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVPortgroupConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortgroupReconfigureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVPortgroupReconfigureRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVPortgroupReconfigureRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "DVPortgroupReconfigureRequestType_Holder" + self.pyclass = Holder + + class DistributedVirtualPortgroupInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualPortgroupInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualPortgroupInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"switchName"), aname="_switchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupType"), aname="_portgroupType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uplinkPortgroup"), aname="_uplinkPortgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualPortgroupInfo_Def.__bases__: + bases = list(ns0.DistributedVirtualPortgroupInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualPortgroupInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualPortgroupInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualPortgroupInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualPortgroupInfo_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualPortgroupInfo",lazy=True)(pname=(ns,"DistributedVirtualPortgroupInfo"), aname="_DistributedVirtualPortgroupInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualPortgroupInfo = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualPortgroupInfo_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"switchName"), aname="_switchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchInfo_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualSwitchInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualSwitchInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualSwitchInfo_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchInfo",lazy=True)(pname=(ns,"DistributedVirtualSwitchInfo"), aname="_DistributedVirtualSwitchInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualSwitchInfo = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualSwitchInfo_Holder" + self.pyclass = Holder + + class DVSManagerDvsConfigTarget_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSManagerDvsConfigTarget") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSManagerDvsConfigTarget_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualPortgroupInfo",lazy=True)(pname=(ns,"distributedVirtualPortgroup"), aname="_distributedVirtualPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchInfo",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DVSManagerDvsConfigTarget_Def.__bases__: + bases = list(ns0.DVSManagerDvsConfigTarget_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DVSManagerDvsConfigTarget_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSManagerQueryAvailableSwitchSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSManagerQueryAvailableSwitchSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DVSManagerQueryAvailableSwitchSpecRequestType_Holder" + self.pyclass = Holder + + class DVSManagerQueryCompatibleHostForNewDvsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSManagerQueryCompatibleHostForNewDvsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"container"), aname="_container", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recursive"), aname="_recursive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"switchProductSpec"), aname="_switchProductSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._container = None + self._recursive = None + self._switchProductSpec = None + return + Holder.__name__ = "DVSManagerQueryCompatibleHostForNewDvsRequestType_Holder" + self.pyclass = Holder + + class DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSManagerQueryCompatibleHostForExistingDvsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"container"), aname="_container", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recursive"), aname="_recursive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._container = None + self._recursive = None + self._dvs = None + return + Holder.__name__ = "DVSManagerQueryCompatibleHostForExistingDvsRequestType_Holder" + self.pyclass = Holder + + class DVSManagerQueryCompatibleHostSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSManagerQueryCompatibleHostSpecRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"switchProductSpec"), aname="_switchProductSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._switchProductSpec = None + return + Holder.__name__ = "DVSManagerQueryCompatibleHostSpecRequestType_Holder" + self.pyclass = Holder + + class DVSManagerQuerySwitchByUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSManagerQuerySwitchByUuidRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSManagerQuerySwitchByUuidRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._uuid = None + return + Holder.__name__ = "DVSManagerQuerySwitchByUuidRequestType_Holder" + self.pyclass = Holder + + class DVSManagerQueryDvsConfigTargetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DVSManagerQueryDvsConfigTargetRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DVSManagerQueryDvsConfigTargetRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._dvs = None + return + Holder.__name__ = "DVSManagerQueryDvsConfigTargetRequestType_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchHostMemberHostComponentState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostMemberHostComponentState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DistributedVirtualSwitchHostMemberConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostMemberConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMemberBacking",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxProxySwitchPorts"), aname="_maxProxySwitchPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualSwitchHostMemberConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualSwitchHostMemberConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualSwitchHostMemberConfigSpec_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberConfigSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostMemberConfigSpec"), aname="_DistributedVirtualSwitchHostMemberConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualSwitchHostMemberConfigSpec = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostMemberConfigSpec_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchHostMemberPnicSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostMemberPnicSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"pnicDevice"), aname="_pnicDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uplinkPortKey"), aname="_uplinkPortKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uplinkPortgroupKey"), aname="_uplinkPortgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"connectionCookie"), aname="_connectionCookie", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualSwitchHostMemberPnicSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualSwitchHostMemberPnicSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualSwitchHostMemberPnicSpec_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberPnicSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostMemberPnicSpec"), aname="_DistributedVirtualSwitchHostMemberPnicSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualSwitchHostMemberPnicSpec = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostMemberPnicSpec_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchHostMemberBacking_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostMemberBacking") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchHostMemberBacking_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberBacking_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchHostMemberBacking_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchHostMemberBacking_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualSwitchHostMemberPnicBacking_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostMemberPnicBacking") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberPnicSpec",lazy=True)(pname=(ns,"pnicSpec"), aname="_pnicSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DistributedVirtualSwitchHostMemberBacking_Def not in ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.__bases__) + bases.insert(0, ns0.DistributedVirtualSwitchHostMemberBacking_Def) + ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.__bases__ = tuple(bases) + + ns0.DistributedVirtualSwitchHostMemberBacking_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualSwitchHostMemberConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostMemberConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxProxySwitchPorts"), aname="_maxProxySwitchPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMemberBacking",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualSwitchHostMember_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostMember") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchHostMember_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberConfigInfo",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uplinkPortKey"), aname="_uplinkPortKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMember_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchHostMember_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchHostMember_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualSwitchHostMember_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualSwitchHostMember") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualSwitchHostMember_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMember",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostMember"), aname="_DistributedVirtualSwitchHostMember", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualSwitchHostMember = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostMember_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchHostProductSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchHostProductSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchHostProductSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"productLineId"), aname="_productLineId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostProductSpec_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchHostProductSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchHostProductSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualSwitchHostProductSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualSwitchHostProductSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualSwitchHostProductSpec_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostProductSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostProductSpec"), aname="_DistributedVirtualSwitchHostProductSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualSwitchHostProductSpec = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostProductSpec_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchKeyedOpaqueBlob_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchKeyedOpaqueBlob") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"opaqueData"), aname="_opaqueData", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"DistributedVirtualSwitchKeyedOpaqueBlob"), aname="_DistributedVirtualSwitchKeyedOpaqueBlob", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualSwitchKeyedOpaqueBlob = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob_Holder" + self.pyclass = Holder + + class DistributedVirtualSwitchPortConnecteeConnecteeType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchPortConnecteeConnecteeType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DistributedVirtualSwitchPortConnectee_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchPortConnectee") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchPortConnectee_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"connectedEntity"), aname="_connectedEntity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicKey"), aname="_nicKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"addressHint"), aname="_addressHint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortConnectee_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchPortConnectee_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchPortConnectee_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualSwitchPortConnection_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchPortConnection") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchPortConnection_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"connectionCookie"), aname="_connectionCookie", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortConnection_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchPortConnection_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchPortConnection_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualSwitchPortCriteria_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchPortCriteria") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchPortCriteria_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"active"), aname="_active", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uplinkPort"), aname="_uplinkPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inside"), aname="_inside", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortCriteria_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchPortCriteria_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchPortCriteria_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualSwitchPortStatistics_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchPortStatistics") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchPortStatistics_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"packetsInMulticast"), aname="_packetsInMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutMulticast"), aname="_packetsOutMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesInMulticast"), aname="_bytesInMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesOutMulticast"), aname="_bytesOutMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInUnicast"), aname="_packetsInUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutUnicast"), aname="_packetsOutUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesInUnicast"), aname="_bytesInUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesOutUnicast"), aname="_bytesOutUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInBroadcast"), aname="_packetsInBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutBroadcast"), aname="_packetsOutBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesInBroadcast"), aname="_bytesInBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesOutBroadcast"), aname="_bytesOutBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInDropped"), aname="_packetsInDropped", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutDropped"), aname="_packetsOutDropped", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInException"), aname="_packetsInException", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutException"), aname="_packetsOutException", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortStatistics_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchPortStatistics_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchPortStatistics_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DistributedVirtualSwitchProductSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DistributedVirtualSwitchProductSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DistributedVirtualSwitchProductSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"build"), aname="_build", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"forwardingClass"), aname="_forwardingClass", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleId"), aname="_bundleId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrl"), aname="_bundleUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchProductSpec_Def.__bases__: + bases = list(ns0.DistributedVirtualSwitchProductSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DistributedVirtualSwitchProductSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDistributedVirtualSwitchProductSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDistributedVirtualSwitchProductSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDistributedVirtualSwitchProductSpec_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchProductSpec"), aname="_DistributedVirtualSwitchProductSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DistributedVirtualSwitchProductSpec = [] + return + Holder.__name__ = "ArrayOfDistributedVirtualSwitchProductSpec_Holder" + self.pyclass = Holder + + class VMwareDVSConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMwareDVSConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMwareDVSConfigInfo_Def.schema + TClist = [GTD("urn:vim25","VMwareDVSPvlanMapEntry",lazy=True)(pname=(ns,"pvlanConfig"), aname="_pvlanConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMtu"), aname="_maxMtu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkDiscoveryProtocolConfig",lazy=True)(pname=(ns,"linkDiscoveryProtocolConfig"), aname="_linkDiscoveryProtocolConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVSConfigInfo_Def not in ns0.VMwareDVSConfigInfo_Def.__bases__: + bases = list(ns0.VMwareDVSConfigInfo_Def.__bases__) + bases.insert(0, ns0.DVSConfigInfo_Def) + ns0.VMwareDVSConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DVSConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMwareDVSConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMwareDVSConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMwareDVSConfigSpec_Def.schema + TClist = [GTD("urn:vim25","VMwareDVSPvlanConfigSpec",lazy=True)(pname=(ns,"pvlanConfigSpec"), aname="_pvlanConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMtu"), aname="_maxMtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkDiscoveryProtocolConfig",lazy=True)(pname=(ns,"linkDiscoveryProtocolConfig"), aname="_linkDiscoveryProtocolConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVSConfigSpec_Def not in ns0.VMwareDVSConfigSpec_Def.__bases__: + bases = list(ns0.VMwareDVSConfigSpec_Def.__bases__) + bases.insert(0, ns0.DVSConfigSpec_Def) + ns0.VMwareDVSConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DVSConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMwareUplinkPortOrderPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMwareUplinkPortOrderPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMwareUplinkPortOrderPolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"activeUplinkPort"), aname="_activeUplinkPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"standbyUplinkPort"), aname="_standbyUplinkPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.VMwareUplinkPortOrderPolicy_Def.__bases__: + bases = list(ns0.VMwareUplinkPortOrderPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.VMwareUplinkPortOrderPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSFailureCriteria_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSFailureCriteria") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSFailureCriteria_Def.schema + TClist = [GTD("urn:vim25","StringPolicy",lazy=True)(pname=(ns,"checkSpeed"), aname="_checkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntPolicy",lazy=True)(pname=(ns,"speed"), aname="_speed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"checkDuplex"), aname="_checkDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"fullDuplex"), aname="_fullDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"checkErrorPercent"), aname="_checkErrorPercent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntPolicy",lazy=True)(pname=(ns,"percentage"), aname="_percentage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"checkBeacon"), aname="_checkBeacon", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.DVSFailureCriteria_Def.__bases__: + bases = list(ns0.DVSFailureCriteria_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.DVSFailureCriteria_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmwareUplinkPortTeamingPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmwareUplinkPortTeamingPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmwareUplinkPortTeamingPolicy_Def.schema + TClist = [GTD("urn:vim25","StringPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"reversePolicy"), aname="_reversePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"notifySwitches"), aname="_notifySwitches", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"rollingOrder"), aname="_rollingOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSFailureCriteria",lazy=True)(pname=(ns,"failureCriteria"), aname="_failureCriteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VMwareUplinkPortOrderPolicy",lazy=True)(pname=(ns,"uplinkPortOrder"), aname="_uplinkPortOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.VmwareUplinkPortTeamingPolicy_Def.__bases__: + bases = list(ns0.VmwareUplinkPortTeamingPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.VmwareUplinkPortTeamingPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmwareDistributedVirtualSwitchVlanSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmwareDistributedVirtualSwitchVlanSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__bases__: + bases = list(ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmwareDistributedVirtualSwitchPvlanSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmwareDistributedVirtualSwitchPvlanSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"pvlanId"), aname="_pvlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmwareDistributedVirtualSwitchVlanSpec_Def not in ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.__bases__: + bases = list(ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.__bases__) + bases.insert(0, ns0.VmwareDistributedVirtualSwitchVlanSpec_Def) + ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.__bases__ = tuple(bases) + + ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmwareDistributedVirtualSwitchVlanIdSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmwareDistributedVirtualSwitchVlanIdSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmwareDistributedVirtualSwitchVlanSpec_Def not in ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.__bases__: + bases = list(ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.__bases__) + bases.insert(0, ns0.VmwareDistributedVirtualSwitchVlanSpec_Def) + ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.__bases__ = tuple(bases) + + ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmwareDistributedVirtualSwitchTrunkVlanSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmwareDistributedVirtualSwitchTrunkVlanSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.schema + TClist = [GTD("urn:vim25","NumericRange",lazy=True)(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmwareDistributedVirtualSwitchVlanSpec_Def not in ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.__bases__: + bases = list(ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.__bases__) + bases.insert(0, ns0.VmwareDistributedVirtualSwitchVlanSpec_Def) + ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.__bases__ = tuple(bases) + + ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVSSecurityPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVSSecurityPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVSSecurityPolicy_Def.schema + TClist = [GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"allowPromiscuous"), aname="_allowPromiscuous", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"macChanges"), aname="_macChanges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"forgedTransmits"), aname="_forgedTransmits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InheritablePolicy_Def not in ns0.DVSSecurityPolicy_Def.__bases__: + bases = list(ns0.DVSSecurityPolicy_Def.__bases__) + bases.insert(0, ns0.InheritablePolicy_Def) + ns0.DVSSecurityPolicy_Def.__bases__ = tuple(bases) + + ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMwareDVSPortSetting_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMwareDVSPortSetting") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMwareDVSPortSetting_Def.schema + TClist = [GTD("urn:vim25","VmwareDistributedVirtualSwitchVlanSpec",lazy=True)(pname=(ns,"vlan"), aname="_vlan", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntPolicy",lazy=True)(pname=(ns,"qosTag"), aname="_qosTag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmwareUplinkPortTeamingPolicy",lazy=True)(pname=(ns,"uplinkTeamingPolicy"), aname="_uplinkTeamingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSSecurityPolicy",lazy=True)(pname=(ns,"securityPolicy"), aname="_securityPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"txUplink"), aname="_txUplink", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVPortSetting_Def not in ns0.VMwareDVSPortSetting_Def.__bases__: + bases = list(ns0.VMwareDVSPortSetting_Def.__bases__) + bases.insert(0, ns0.DVPortSetting_Def) + ns0.VMwareDVSPortSetting_Def.__bases__ = tuple(bases) + + ns0.DVPortSetting_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMwareDVSPortgroupPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMwareDVSPortgroupPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMwareDVSPortgroupPolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"vlanOverrideAllowed"), aname="_vlanOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uplinkTeamingOverrideAllowed"), aname="_uplinkTeamingOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"securityPolicyOverrideAllowed"), aname="_securityPolicyOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVPortgroupPolicy_Def not in ns0.VMwareDVSPortgroupPolicy_Def.__bases__: + bases = list(ns0.VMwareDVSPortgroupPolicy_Def.__bases__) + bases.insert(0, ns0.DVPortgroupPolicy_Def) + ns0.VMwareDVSPortgroupPolicy_Def.__bases__ = tuple(bases) + + ns0.DVPortgroupPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmwareDistributedVirtualSwitchPvlanPortType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VmwareDistributedVirtualSwitchPvlanPortType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VMwareDVSPvlanConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMwareDVSPvlanConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMwareDVSPvlanConfigSpec_Def.schema + TClist = [GTD("urn:vim25","VMwareDVSPvlanMapEntry",lazy=True)(pname=(ns,"pvlanEntry"), aname="_pvlanEntry", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VMwareDVSPvlanConfigSpec_Def.__bases__: + bases = list(ns0.VMwareDVSPvlanConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VMwareDVSPvlanConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVMwareDVSPvlanConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVMwareDVSPvlanConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVMwareDVSPvlanConfigSpec_Def.schema + TClist = [GTD("urn:vim25","VMwareDVSPvlanConfigSpec",lazy=True)(pname=(ns,"VMwareDVSPvlanConfigSpec"), aname="_VMwareDVSPvlanConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VMwareDVSPvlanConfigSpec = [] + return + Holder.__name__ = "ArrayOfVMwareDVSPvlanConfigSpec_Holder" + self.pyclass = Holder + + class VMwareDVSPvlanMapEntry_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMwareDVSPvlanMapEntry") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMwareDVSPvlanMapEntry_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"primaryVlanId"), aname="_primaryVlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"secondaryVlanId"), aname="_secondaryVlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pvlanType"), aname="_pvlanType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VMwareDVSPvlanMapEntry_Def.__bases__: + bases = list(ns0.VMwareDVSPvlanMapEntry_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VMwareDVSPvlanMapEntry_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVMwareDVSPvlanMapEntry_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVMwareDVSPvlanMapEntry") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVMwareDVSPvlanMapEntry_Def.schema + TClist = [GTD("urn:vim25","VMwareDVSPvlanMapEntry",lazy=True)(pname=(ns,"VMwareDVSPvlanMapEntry"), aname="_VMwareDVSPvlanMapEntry", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VMwareDVSPvlanMapEntry = [] + return + Holder.__name__ = "ArrayOfVMwareDVSPvlanMapEntry_Holder" + self.pyclass = Holder + + class EventEventSeverity_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EventEventSeverity") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class Event_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Event") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Event_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"chainId"), aname="_chainId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"createdTime"), aname="_createdTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatacenterEventArgument",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComputeResourceEventArgument",lazy=True)(pname=(ns,"computeResource"), aname="_computeResource", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"ds"), aname="_ds", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkEventArgument",lazy=True)(pname=(ns,"net"), aname="_net", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsEventArgument",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullFormattedMessage"), aname="_fullFormattedMessage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeTag"), aname="_changeTag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.Event_Def.__bases__: + bases = list(ns0.Event_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.Event_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfEvent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfEvent") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfEvent_Def.schema + TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"Event"), aname="_Event", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._Event = [] + return + Holder.__name__ = "ArrayOfEvent_Holder" + self.pyclass = Holder + + class EventEx_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventEx") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventEx_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"severity"), aname="_severity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"arguments"), aname="_arguments", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectId"), aname="_objectId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectType"), aname="_objectType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.EventEx_Def.__bases__: + bases = list(ns0.EventEx_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.EventEx_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.GeneralEvent_Def.__bases__: + bases = list(ns0.GeneralEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.GeneralEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralHostInfoEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralHostInfoEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralHostInfoEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.GeneralHostInfoEvent_Def.__bases__: + bases = list(ns0.GeneralHostInfoEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.GeneralHostInfoEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralHostWarningEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralHostWarningEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralHostWarningEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.GeneralHostWarningEvent_Def.__bases__: + bases = list(ns0.GeneralHostWarningEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.GeneralHostWarningEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralHostErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralHostErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralHostErrorEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.GeneralHostErrorEvent_Def.__bases__: + bases = list(ns0.GeneralHostErrorEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.GeneralHostErrorEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralVmInfoEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralVmInfoEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralVmInfoEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.GeneralVmInfoEvent_Def.__bases__: + bases = list(ns0.GeneralVmInfoEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.GeneralVmInfoEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralVmWarningEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralVmWarningEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralVmWarningEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.GeneralVmWarningEvent_Def.__bases__: + bases = list(ns0.GeneralVmWarningEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.GeneralVmWarningEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralVmErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralVmErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralVmErrorEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.GeneralVmErrorEvent_Def.__bases__: + bases = list(ns0.GeneralVmErrorEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.GeneralVmErrorEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GeneralUserEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GeneralUserEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GeneralUserEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.GeneralUserEvent_Def.__bases__: + bases = list(ns0.GeneralUserEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.GeneralUserEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExtendedEventPair_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtendedEventPair") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtendedEventPair_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ExtendedEventPair_Def.__bases__: + bases = list(ns0.ExtendedEventPair_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ExtendedEventPair_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfExtendedEventPair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfExtendedEventPair") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfExtendedEventPair_Def.schema + TClist = [GTD("urn:vim25","ExtendedEventPair",lazy=True)(pname=(ns,"ExtendedEventPair"), aname="_ExtendedEventPair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ExtendedEventPair = [] + return + Holder.__name__ = "ArrayOfExtendedEventPair_Holder" + self.pyclass = Holder + + class ExtendedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtendedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtendedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"managedObject"), aname="_managedObject", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtendedEventPair",lazy=True)(pname=(ns,"data"), aname="_data", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.GeneralEvent_Def not in ns0.ExtendedEvent_Def.__bases__: + bases = list(ns0.ExtendedEvent_Def.__bases__) + bases.insert(0, ns0.GeneralEvent_Def) + ns0.ExtendedEvent_Def.__bases__ = tuple(bases) + + ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HealthStatusChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HealthStatusChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HealthStatusChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"componentId"), aname="_componentId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"oldStatus"), aname="_oldStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newStatus"), aname="_newStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"componentName"), aname="_componentName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.HealthStatusChangedEvent_Def.__bases__: + bases = list(ns0.HealthStatusChangedEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.HealthStatusChangedEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInventoryUnreadableEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInventoryUnreadableEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInventoryUnreadableEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.HostInventoryUnreadableEvent_Def.__bases__: + bases = list(ns0.HostInventoryUnreadableEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.HostInventoryUnreadableEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatacenterEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatacenterEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatacenterEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.DatacenterEvent_Def.__bases__: + bases = list(ns0.DatacenterEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.DatacenterEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatacenterCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatacenterCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatacenterCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatacenterEvent_Def not in ns0.DatacenterCreatedEvent_Def.__bases__: + bases = list(ns0.DatacenterCreatedEvent_Def.__bases__) + bases.insert(0, ns0.DatacenterEvent_Def) + ns0.DatacenterCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.DatacenterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatacenterRenamedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatacenterRenamedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatacenterRenamedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatacenterEvent_Def not in ns0.DatacenterRenamedEvent_Def.__bases__: + bases = list(ns0.DatacenterRenamedEvent_Def.__bases__) + bases.insert(0, ns0.DatacenterEvent_Def) + ns0.DatacenterRenamedEvent_Def.__bases__ = tuple(bases) + + ns0.DatacenterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SessionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SessionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SessionEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.SessionEvent_Def.__bases__: + bases = list(ns0.SessionEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.SessionEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ServerStartedSessionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ServerStartedSessionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ServerStartedSessionEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.ServerStartedSessionEvent_Def.__bases__: + bases = list(ns0.ServerStartedSessionEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.ServerStartedSessionEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserLoginSessionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserLoginSessionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserLoginSessionEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.UserLoginSessionEvent_Def.__bases__: + bases = list(ns0.UserLoginSessionEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.UserLoginSessionEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserLogoutSessionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserLogoutSessionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserLogoutSessionEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.UserLogoutSessionEvent_Def.__bases__: + bases = list(ns0.UserLogoutSessionEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.UserLogoutSessionEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class BadUsernameSessionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "BadUsernameSessionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.BadUsernameSessionEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.BadUsernameSessionEvent_Def.__bases__: + bases = list(ns0.BadUsernameSessionEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.BadUsernameSessionEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlreadyAuthenticatedSessionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlreadyAuthenticatedSessionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlreadyAuthenticatedSessionEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.AlreadyAuthenticatedSessionEvent_Def.__bases__: + bases = list(ns0.AlreadyAuthenticatedSessionEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.AlreadyAuthenticatedSessionEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoAccessUserEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoAccessUserEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoAccessUserEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.NoAccessUserEvent_Def.__bases__: + bases = list(ns0.NoAccessUserEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.NoAccessUserEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SessionTerminatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SessionTerminatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SessionTerminatedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"terminatedUsername"), aname="_terminatedUsername", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.SessionTerminatedEvent_Def.__bases__: + bases = list(ns0.SessionTerminatedEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.SessionTerminatedEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GlobalMessageChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GlobalMessageChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GlobalMessageChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SessionEvent_Def not in ns0.GlobalMessageChangedEvent_Def.__bases__: + bases = list(ns0.GlobalMessageChangedEvent_Def.__bases__) + bases.insert(0, ns0.SessionEvent_Def) + ns0.GlobalMessageChangedEvent_Def.__bases__ = tuple(bases) + + ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpgradeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UpgradeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UpgradeEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.UpgradeEvent_Def.__bases__: + bases = list(ns0.UpgradeEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.UpgradeEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InfoUpgradeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InfoUpgradeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InfoUpgradeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.UpgradeEvent_Def not in ns0.InfoUpgradeEvent_Def.__bases__: + bases = list(ns0.InfoUpgradeEvent_Def.__bases__) + bases.insert(0, ns0.UpgradeEvent_Def) + ns0.InfoUpgradeEvent_Def.__bases__ = tuple(bases) + + ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class WarningUpgradeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "WarningUpgradeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.WarningUpgradeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.UpgradeEvent_Def not in ns0.WarningUpgradeEvent_Def.__bases__: + bases = list(ns0.WarningUpgradeEvent_Def.__bases__) + bases.insert(0, ns0.UpgradeEvent_Def) + ns0.WarningUpgradeEvent_Def.__bases__ = tuple(bases) + + ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ErrorUpgradeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ErrorUpgradeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ErrorUpgradeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.UpgradeEvent_Def not in ns0.ErrorUpgradeEvent_Def.__bases__: + bases = list(ns0.ErrorUpgradeEvent_Def.__bases__) + bases.insert(0, ns0.UpgradeEvent_Def) + ns0.ErrorUpgradeEvent_Def.__bases__ = tuple(bases) + + ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserUpgradeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserUpgradeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserUpgradeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.UpgradeEvent_Def not in ns0.UserUpgradeEvent_Def.__bases__: + bases = list(ns0.UserUpgradeEvent_Def.__bases__) + bases.insert(0, ns0.UpgradeEvent_Def) + ns0.UserUpgradeEvent_Def.__bases__ = tuple(bases) + + ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.HostEvent_Def.__bases__: + bases = list(ns0.HostEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.HostEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDasEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDasEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDasEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDasEvent_Def.__bases__: + bases = list(ns0.HostDasEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDasEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConnectedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostConnectedEvent_Def.__bases__: + bases = list(ns0.HostConnectedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostConnectedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDisconnectedEventReasonCode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostDisconnectedEventReasonCode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostDisconnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDisconnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDisconnectedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDisconnectedEvent_Def.__bases__: + bases = list(ns0.HostDisconnectedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDisconnectedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostSyncFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSyncFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSyncFailedEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostSyncFailedEvent_Def.__bases__: + bases = list(ns0.HostSyncFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostSyncFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConnectionLostEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConnectionLostEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConnectionLostEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostConnectionLostEvent_Def.__bases__: + bases = list(ns0.HostConnectionLostEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostConnectionLostEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostReconnectionFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostReconnectionFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostReconnectionFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostReconnectionFailedEvent_Def.__bases__: + bases = list(ns0.HostReconnectionFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostReconnectionFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedNoConnectionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedNoConnectionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedNoConnectionEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedNoConnectionEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedNoConnectionEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedNoConnectionEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedBadUsernameEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedBadUsernameEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedBadUsernameEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedBadUsernameEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedBadUsernameEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedBadUsernameEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedBadVersionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedBadVersionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedBadVersionEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedBadVersionEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedBadVersionEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedBadVersionEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedAlreadyManagedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedAlreadyManagedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedAlreadyManagedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"serverName"), aname="_serverName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedAlreadyManagedEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedAlreadyManagedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedAlreadyManagedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedNoLicenseEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedNoLicenseEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedNoLicenseEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedNoLicenseEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedNoLicenseEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedNoLicenseEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedNetworkErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedNetworkErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedNetworkErrorEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedNetworkErrorEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedNetworkErrorEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedNetworkErrorEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostRemovedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostRemovedEvent_Def.__bases__: + bases = list(ns0.HostRemovedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedCcagentUpgradeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedCcagentUpgradeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedCcagentUpgradeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedCcagentUpgradeEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedCcagentUpgradeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedCcagentUpgradeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedBadCcagentEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedBadCcagentEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedBadCcagentEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedBadCcagentEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedBadCcagentEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedBadCcagentEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedAccountFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedAccountFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedAccountFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedAccountFailedEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedAccountFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedAccountFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedNoAccessEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedNoAccessEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedNoAccessEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedNoAccessEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedNoAccessEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedNoAccessEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostShutdownEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostShutdownEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostShutdownEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostShutdownEvent_Def.__bases__: + bases = list(ns0.HostShutdownEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostShutdownEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedNotFoundEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedNotFoundEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedNotFoundEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedNotFoundEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedNotFoundEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedNotFoundEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCnxFailedTimeoutEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCnxFailedTimeoutEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCnxFailedTimeoutEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCnxFailedTimeoutEvent_Def.__bases__: + bases = list(ns0.HostCnxFailedTimeoutEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCnxFailedTimeoutEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostUpgradeFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUpgradeFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUpgradeFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostUpgradeFailedEvent_Def.__bases__: + bases = list(ns0.HostUpgradeFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostUpgradeFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EnteringMaintenanceModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EnteringMaintenanceModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EnteringMaintenanceModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.EnteringMaintenanceModeEvent_Def.__bases__: + bases = list(ns0.EnteringMaintenanceModeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.EnteringMaintenanceModeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EnteredMaintenanceModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EnteredMaintenanceModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EnteredMaintenanceModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.EnteredMaintenanceModeEvent_Def.__bases__: + bases = list(ns0.EnteredMaintenanceModeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.EnteredMaintenanceModeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExitMaintenanceModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExitMaintenanceModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExitMaintenanceModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.ExitMaintenanceModeEvent_Def.__bases__: + bases = list(ns0.ExitMaintenanceModeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.ExitMaintenanceModeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CanceledHostOperationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CanceledHostOperationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CanceledHostOperationEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.CanceledHostOperationEvent_Def.__bases__: + bases = list(ns0.CanceledHostOperationEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.CanceledHostOperationEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TimedOutHostOperationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TimedOutHostOperationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TimedOutHostOperationEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.TimedOutHostOperationEvent_Def.__bases__: + bases = list(ns0.TimedOutHostOperationEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.TimedOutHostOperationEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDasEnabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDasEnabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDasEnabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDasEnabledEvent_Def.__bases__: + bases = list(ns0.HostDasEnabledEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDasEnabledEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDasDisabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDasDisabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDasDisabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDasDisabledEvent_Def.__bases__: + bases = list(ns0.HostDasDisabledEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDasDisabledEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDasEnablingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDasEnablingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDasEnablingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDasEnablingEvent_Def.__bases__: + bases = list(ns0.HostDasEnablingEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDasEnablingEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDasDisablingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDasDisablingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDasDisablingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDasDisablingEvent_Def.__bases__: + bases = list(ns0.HostDasDisablingEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDasDisablingEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDasErrorEventHostDasErrorReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostDasErrorEventHostDasErrorReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostDasErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDasErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDasErrorEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDasErrorEvent_Def.__bases__: + bases = list(ns0.HostDasErrorEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDasErrorEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDasOkEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDasOkEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDasOkEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostDasOkEvent_Def.__bases__: + bases = list(ns0.HostDasOkEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostDasOkEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VcAgentUpgradedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VcAgentUpgradedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VcAgentUpgradedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VcAgentUpgradedEvent_Def.__bases__: + bases = list(ns0.VcAgentUpgradedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VcAgentUpgradedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VcAgentUninstalledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VcAgentUninstalledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VcAgentUninstalledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VcAgentUninstalledEvent_Def.__bases__: + bases = list(ns0.VcAgentUninstalledEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VcAgentUninstalledEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VcAgentUpgradeFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VcAgentUpgradeFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VcAgentUpgradeFailedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VcAgentUpgradeFailedEvent_Def.__bases__: + bases = list(ns0.VcAgentUpgradeFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VcAgentUpgradeFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VcAgentUninstallFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VcAgentUninstallFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VcAgentUninstallFailedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VcAgentUninstallFailedEvent_Def.__bases__: + bases = list(ns0.VcAgentUninstallFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VcAgentUninstallFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostAddedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostAddedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostAddedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostAddedEvent_Def.__bases__: + bases = list(ns0.HostAddedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostAddedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostAddFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostAddFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostAddFailedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostAddFailedEvent_Def.__bases__: + bases = list(ns0.HostAddFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostAddFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldIP"), aname="_oldIP", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newIP"), aname="_newIP", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostIpChangedEvent_Def.__bases__: + bases = list(ns0.HostIpChangedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostIpChangedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EnteringStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EnteringStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EnteringStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.EnteringStandbyModeEvent_Def.__bases__: + bases = list(ns0.EnteringStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.EnteringStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsEnteringStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsEnteringStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsEnteringStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EnteringStandbyModeEvent_Def not in ns0.DrsEnteringStandbyModeEvent_Def.__bases__: + bases = list(ns0.DrsEnteringStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.EnteringStandbyModeEvent_Def) + ns0.DrsEnteringStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.EnteringStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EnteredStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EnteredStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EnteredStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.EnteredStandbyModeEvent_Def.__bases__: + bases = list(ns0.EnteredStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.EnteredStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsEnteredStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsEnteredStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsEnteredStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EnteredStandbyModeEvent_Def not in ns0.DrsEnteredStandbyModeEvent_Def.__bases__: + bases = list(ns0.DrsEnteredStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.EnteredStandbyModeEvent_Def) + ns0.DrsEnteredStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.EnteredStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExitingStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExitingStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExitingStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.ExitingStandbyModeEvent_Def.__bases__: + bases = list(ns0.ExitingStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.ExitingStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsExitingStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsExitingStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsExitingStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ExitingStandbyModeEvent_Def not in ns0.DrsExitingStandbyModeEvent_Def.__bases__: + bases = list(ns0.DrsExitingStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.ExitingStandbyModeEvent_Def) + ns0.DrsExitingStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.ExitingStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExitedStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExitedStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExitedStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.ExitedStandbyModeEvent_Def.__bases__: + bases = list(ns0.ExitedStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.ExitedStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsExitedStandbyModeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsExitedStandbyModeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsExitedStandbyModeEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ExitedStandbyModeEvent_Def not in ns0.DrsExitedStandbyModeEvent_Def.__bases__: + bases = list(ns0.DrsExitedStandbyModeEvent_Def.__bases__) + bases.insert(0, ns0.ExitedStandbyModeEvent_Def) + ns0.DrsExitedStandbyModeEvent_Def.__bases__ = tuple(bases) + + ns0.ExitedStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExitStandbyModeFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExitStandbyModeFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExitStandbyModeFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.ExitStandbyModeFailedEvent_Def.__bases__: + bases = list(ns0.ExitStandbyModeFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.ExitStandbyModeFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsExitStandbyModeFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsExitStandbyModeFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsExitStandbyModeFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ExitStandbyModeFailedEvent_Def not in ns0.DrsExitStandbyModeFailedEvent_Def.__bases__: + bases = list(ns0.DrsExitStandbyModeFailedEvent_Def.__bases__) + bases.insert(0, ns0.ExitStandbyModeFailedEvent_Def) + ns0.DrsExitStandbyModeFailedEvent_Def.__bases__ = tuple(bases) + + ns0.ExitStandbyModeFailedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdatedAgentBeingRestartedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UpdatedAgentBeingRestartedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UpdatedAgentBeingRestartedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.UpdatedAgentBeingRestartedEvent_Def.__bases__: + bases = list(ns0.UpdatedAgentBeingRestartedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.UpdatedAgentBeingRestartedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AccountCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AccountCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AccountCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.AccountCreatedEvent_Def.__bases__: + bases = list(ns0.AccountCreatedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.AccountCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AccountRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AccountRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AccountRemovedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"account"), aname="_account", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.AccountRemovedEvent_Def.__bases__: + bases = list(ns0.AccountRemovedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.AccountRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserPasswordChanged_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserPasswordChanged") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserPasswordChanged_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userLogin"), aname="_userLogin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.UserPasswordChanged_Def.__bases__: + bases = list(ns0.UserPasswordChanged_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.UserPasswordChanged_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AccountUpdatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AccountUpdatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AccountUpdatedEvent_Def.schema + TClist = [GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.AccountUpdatedEvent_Def.__bases__: + bases = list(ns0.AccountUpdatedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.AccountUpdatedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserAssignedToGroup_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserAssignedToGroup") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserAssignedToGroup_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userLogin"), aname="_userLogin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.UserAssignedToGroup_Def.__bases__: + bases = list(ns0.UserAssignedToGroup_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.UserAssignedToGroup_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserUnassignedFromGroup_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserUnassignedFromGroup") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserUnassignedFromGroup_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userLogin"), aname="_userLogin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.UserUnassignedFromGroup_Def.__bases__: + bases = list(ns0.UserUnassignedFromGroup_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.UserUnassignedFromGroup_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastorePrincipalConfigured_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastorePrincipalConfigured") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastorePrincipalConfigured_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"datastorePrincipal"), aname="_datastorePrincipal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.DatastorePrincipalConfigured_Def.__bases__: + bases = list(ns0.DatastorePrincipalConfigured_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.DatastorePrincipalConfigured_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMFSDatastoreCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMFSDatastoreCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMFSDatastoreCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VMFSDatastoreCreatedEvent_Def.__bases__: + bases = list(ns0.VMFSDatastoreCreatedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VMFSDatastoreCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NASDatastoreCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NASDatastoreCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NASDatastoreCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.NASDatastoreCreatedEvent_Def.__bases__: + bases = list(ns0.NASDatastoreCreatedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.NASDatastoreCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LocalDatastoreCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LocalDatastoreCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LocalDatastoreCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.LocalDatastoreCreatedEvent_Def.__bases__: + bases = list(ns0.LocalDatastoreCreatedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.LocalDatastoreCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMFSDatastoreExtendedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMFSDatastoreExtendedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMFSDatastoreExtendedEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VMFSDatastoreExtendedEvent_Def.__bases__: + bases = list(ns0.VMFSDatastoreExtendedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VMFSDatastoreExtendedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMFSDatastoreExpandedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMFSDatastoreExpandedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMFSDatastoreExpandedEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VMFSDatastoreExpandedEvent_Def.__bases__: + bases = list(ns0.VMFSDatastoreExpandedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VMFSDatastoreExpandedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreRemovedOnHostEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreRemovedOnHostEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreRemovedOnHostEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.DatastoreRemovedOnHostEvent_Def.__bases__: + bases = list(ns0.DatastoreRemovedOnHostEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.DatastoreRemovedOnHostEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreRenamedOnHostEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreRenamedOnHostEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreRenamedOnHostEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.DatastoreRenamedOnHostEvent_Def.__bases__: + bases = list(ns0.DatastoreRenamedOnHostEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.DatastoreRenamedOnHostEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DuplicateIpDetectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DuplicateIpDetectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DuplicateIpDetectedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"duplicateIP"), aname="_duplicateIP", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.DuplicateIpDetectedEvent_Def.__bases__: + bases = list(ns0.DuplicateIpDetectedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.DuplicateIpDetectedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreDiscoveredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreDiscoveredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreDiscoveredEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.DatastoreDiscoveredEvent_Def.__bases__: + bases = list(ns0.DatastoreDiscoveredEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.DatastoreDiscoveredEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsResourceConfigureFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsResourceConfigureFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsResourceConfigureFailedEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.DrsResourceConfigureFailedEvent_Def.__bases__: + bases = list(ns0.DrsResourceConfigureFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.DrsResourceConfigureFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsResourceConfigureSyncedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsResourceConfigureSyncedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsResourceConfigureSyncedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.DrsResourceConfigureSyncedEvent_Def.__bases__: + bases = list(ns0.DrsResourceConfigureSyncedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.DrsResourceConfigureSyncedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostGetShortNameFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostGetShortNameFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostGetShortNameFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostGetShortNameFailedEvent_Def.__bases__: + bases = list(ns0.HostGetShortNameFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostGetShortNameFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostShortNameToIpFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostShortNameToIpFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostShortNameToIpFailedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"shortName"), aname="_shortName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostShortNameToIpFailedEvent_Def.__bases__: + bases = list(ns0.HostShortNameToIpFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostShortNameToIpFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpToShortNameFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpToShortNameFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpToShortNameFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostIpToShortNameFailedEvent_Def.__bases__: + bases = list(ns0.HostIpToShortNameFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostIpToShortNameFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostPrimaryAgentNotShortNameEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPrimaryAgentNotShortNameEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPrimaryAgentNotShortNameEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"primaryAgent"), aname="_primaryAgent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostPrimaryAgentNotShortNameEvent_Def.__bases__: + bases = list(ns0.HostPrimaryAgentNotShortNameEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostPrimaryAgentNotShortNameEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNotInClusterEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNotInClusterEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNotInClusterEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostNotInClusterEvent_Def.__bases__: + bases = list(ns0.HostNotInClusterEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostNotInClusterEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIsolationIpPingFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIsolationIpPingFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIsolationIpPingFailedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"isolationIp"), aname="_isolationIp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostIsolationIpPingFailedEvent_Def.__bases__: + bases = list(ns0.HostIsolationIpPingFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostIsolationIpPingFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpInconsistentEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpInconsistentEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpInconsistentEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress2"), aname="_ipAddress2", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostIpInconsistentEvent_Def.__bases__: + bases = list(ns0.HostIpInconsistentEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostIpInconsistentEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostUserWorldSwapNotEnabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUserWorldSwapNotEnabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUserWorldSwapNotEnabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostUserWorldSwapNotEnabledEvent_Def.__bases__: + bases = list(ns0.HostUserWorldSwapNotEnabledEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostUserWorldSwapNotEnabledEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNonCompliantEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNonCompliantEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNonCompliantEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostNonCompliantEvent_Def.__bases__: + bases = list(ns0.HostNonCompliantEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostNonCompliantEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCompliantEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCompliantEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCompliantEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostCompliantEvent_Def.__bases__: + bases = list(ns0.HostCompliantEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostCompliantEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostComplianceCheckedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostComplianceCheckedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostComplianceCheckedEvent_Def.schema + TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostComplianceCheckedEvent_Def.__bases__: + bases = list(ns0.HostComplianceCheckedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostComplianceCheckedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterComplianceCheckedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterComplianceCheckedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterComplianceCheckedEvent_Def.schema + TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.ClusterComplianceCheckedEvent_Def.__bases__: + bases = list(ns0.ClusterComplianceCheckedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.ClusterComplianceCheckedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileEvent_Def.schema + TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.ProfileEvent_Def.__bases__: + bases = list(ns0.ProfileEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.ProfileEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileCreatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileEvent_Def not in ns0.ProfileCreatedEvent_Def.__bases__: + bases = list(ns0.ProfileCreatedEvent_Def.__bases__) + bases.insert(0, ns0.ProfileEvent_Def) + ns0.ProfileCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileRemovedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileEvent_Def not in ns0.ProfileRemovedEvent_Def.__bases__: + bases = list(ns0.ProfileRemovedEvent_Def.__bases__) + bases.insert(0, ns0.ProfileEvent_Def) + ns0.ProfileRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileAssociatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileAssociatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileAssociatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileEvent_Def not in ns0.ProfileAssociatedEvent_Def.__bases__: + bases = list(ns0.ProfileAssociatedEvent_Def.__bases__) + bases.insert(0, ns0.ProfileEvent_Def) + ns0.ProfileAssociatedEvent_Def.__bases__ = tuple(bases) + + ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileDissociatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileDissociatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileDissociatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileEvent_Def not in ns0.ProfileDissociatedEvent_Def.__bases__: + bases = list(ns0.ProfileDissociatedEvent_Def.__bases__) + bases.insert(0, ns0.ProfileEvent_Def) + ns0.ProfileDissociatedEvent_Def.__bases__ = tuple(bases) + + ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigAppliedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigAppliedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigAppliedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostConfigAppliedEvent_Def.__bases__: + bases = list(ns0.HostConfigAppliedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostConfigAppliedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileReferenceHostChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileReferenceHostChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileReferenceHostChangedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"referenceHost"), aname="_referenceHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileEvent_Def not in ns0.ProfileReferenceHostChangedEvent_Def.__bases__: + bases = list(ns0.ProfileReferenceHostChangedEvent_Def.__bases__) + bases.insert(0, ns0.ProfileEvent_Def) + ns0.ProfileReferenceHostChangedEvent_Def.__bases__ = tuple(bases) + + ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileChangedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileEvent_Def not in ns0.ProfileChangedEvent_Def.__bases__: + bases = list(ns0.ProfileChangedEvent_Def.__bases__) + bases.insert(0, ns0.ProfileEvent_Def) + ns0.ProfileChangedEvent_Def.__bases__ = tuple(bases) + + ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProfileAppliedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProfileAppliedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProfileAppliedEvent_Def.schema + TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostProfileAppliedEvent_Def.__bases__: + bases = list(ns0.HostProfileAppliedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostProfileAppliedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostShortNameInconsistentEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostShortNameInconsistentEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostShortNameInconsistentEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"shortName"), aname="_shortName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"shortName2"), aname="_shortName2", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostShortNameInconsistentEvent_Def.__bases__: + bases = list(ns0.HostShortNameInconsistentEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostShortNameInconsistentEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNoRedundantManagementNetworkEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNoRedundantManagementNetworkEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNoRedundantManagementNetworkEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostNoRedundantManagementNetworkEvent_Def.__bases__: + bases = list(ns0.HostNoRedundantManagementNetworkEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostNoRedundantManagementNetworkEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNoAvailableNetworksEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNoAvailableNetworksEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNoAvailableNetworksEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ips"), aname="_ips", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostNoAvailableNetworksEvent_Def.__bases__: + bases = list(ns0.HostNoAvailableNetworksEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostNoAvailableNetworksEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostExtraNetworksEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostExtraNetworksEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostExtraNetworksEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ips"), aname="_ips", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostExtraNetworksEvent_Def.__bases__: + bases = list(ns0.HostExtraNetworksEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostExtraNetworksEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNoHAEnabledPortGroupsEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNoHAEnabledPortGroupsEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNoHAEnabledPortGroupsEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostNoHAEnabledPortGroupsEvent_Def.__bases__: + bases = list(ns0.HostNoHAEnabledPortGroupsEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostNoHAEnabledPortGroupsEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostMissingNetworksEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMissingNetworksEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMissingNetworksEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ips"), aname="_ips", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDasEvent_Def not in ns0.HostMissingNetworksEvent_Def.__bases__: + bases = list(ns0.HostMissingNetworksEvent_Def.__bases__) + bases.insert(0, ns0.HostDasEvent_Def) + ns0.HostMissingNetworksEvent_Def.__bases__ = tuple(bases) + + ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VnicPortArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VnicPortArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VnicPortArgument_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VnicPortArgument_Def.__bases__: + bases = list(ns0.VnicPortArgument_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VnicPortArgument_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVnicPortArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVnicPortArgument") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVnicPortArgument_Def.schema + TClist = [GTD("urn:vim25","VnicPortArgument",lazy=True)(pname=(ns,"VnicPortArgument"), aname="_VnicPortArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VnicPortArgument = [] + return + Holder.__name__ = "ArrayOfVnicPortArgument_Holder" + self.pyclass = Holder + + class HostVnicConnectedToCustomizedDVPortEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVnicConnectedToCustomizedDVPortEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.schema + TClist = [GTD("urn:vim25","VnicPortArgument",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.__bases__: + bases = list(ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GhostDvsProxySwitchDetectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GhostDvsProxySwitchDetectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GhostDvsProxySwitchDetectedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.GhostDvsProxySwitchDetectedEvent_Def.__bases__: + bases = list(ns0.GhostDvsProxySwitchDetectedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.GhostDvsProxySwitchDetectedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GhostDvsProxySwitchRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GhostDvsProxySwitchRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GhostDvsProxySwitchRemovedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.GhostDvsProxySwitchRemovedEvent_Def.__bases__: + bases = list(ns0.GhostDvsProxySwitchRemovedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.GhostDvsProxySwitchRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmEvent_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.VmEvent_Def.__bases__: + bases = list(ns0.VmEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.VmEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmPoweredOffEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmPoweredOffEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmPoweredOffEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmPoweredOffEvent_Def.__bases__: + bases = list(ns0.VmPoweredOffEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmPoweredOffEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmPoweredOnEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmPoweredOnEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmPoweredOnEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmPoweredOnEvent_Def.__bases__: + bases = list(ns0.VmPoweredOnEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmPoweredOnEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSuspendedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSuspendedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSuspendedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmSuspendedEvent_Def.__bases__: + bases = list(ns0.VmSuspendedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmSuspendedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmStartingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmStartingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmStartingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmStartingEvent_Def.__bases__: + bases = list(ns0.VmStartingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmStartingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmStoppingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmStoppingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmStoppingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmStoppingEvent_Def.__bases__: + bases = list(ns0.VmStoppingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmStoppingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSuspendingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSuspendingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSuspendingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmSuspendingEvent_Def.__bases__: + bases = list(ns0.VmSuspendingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmSuspendingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmResumingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmResumingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmResumingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmResumingEvent_Def.__bases__: + bases = list(ns0.VmResumingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmResumingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDisconnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDisconnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDisconnectedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDisconnectedEvent_Def.__bases__: + bases = list(ns0.VmDisconnectedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDisconnectedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRemoteConsoleConnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRemoteConsoleConnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRemoteConsoleConnectedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRemoteConsoleConnectedEvent_Def.__bases__: + bases = list(ns0.VmRemoteConsoleConnectedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRemoteConsoleConnectedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRemoteConsoleDisconnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRemoteConsoleDisconnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRemoteConsoleDisconnectedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRemoteConsoleDisconnectedEvent_Def.__bases__: + bases = list(ns0.VmRemoteConsoleDisconnectedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRemoteConsoleDisconnectedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDiscoveredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDiscoveredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDiscoveredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDiscoveredEvent_Def.__bases__: + bases = list(ns0.VmDiscoveredEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDiscoveredEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmOrphanedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmOrphanedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmOrphanedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmOrphanedEvent_Def.__bases__: + bases = list(ns0.VmOrphanedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmOrphanedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmBeingCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmBeingCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmBeingCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmBeingCreatedEvent_Def.__bases__: + bases = list(ns0.VmBeingCreatedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmBeingCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmCreatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmCreatedEvent_Def.__bases__: + bases = list(ns0.VmCreatedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmStartRecordingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmStartRecordingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmStartRecordingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmStartRecordingEvent_Def.__bases__: + bases = list(ns0.VmStartRecordingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmStartRecordingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmEndRecordingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmEndRecordingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmEndRecordingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmEndRecordingEvent_Def.__bases__: + bases = list(ns0.VmEndRecordingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmEndRecordingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmStartReplayingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmStartReplayingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmStartReplayingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmStartReplayingEvent_Def.__bases__: + bases = list(ns0.VmStartReplayingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmStartReplayingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmEndReplayingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmEndReplayingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmEndReplayingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmEndReplayingEvent_Def.__bases__: + bases = list(ns0.VmEndReplayingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmEndReplayingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRegisteredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRegisteredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRegisteredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRegisteredEvent_Def.__bases__: + bases = list(ns0.VmRegisteredEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRegisteredEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmAutoRenameEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmAutoRenameEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmAutoRenameEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmAutoRenameEvent_Def.__bases__: + bases = list(ns0.VmAutoRenameEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmAutoRenameEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmBeingHotMigratedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmBeingHotMigratedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmBeingHotMigratedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmBeingHotMigratedEvent_Def.__bases__: + bases = list(ns0.VmBeingHotMigratedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmBeingHotMigratedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmResettingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmResettingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmResettingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmResettingEvent_Def.__bases__: + bases = list(ns0.VmResettingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmResettingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmStaticMacConflictEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmStaticMacConflictEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmStaticMacConflictEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmStaticMacConflictEvent_Def.__bases__: + bases = list(ns0.VmStaticMacConflictEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmStaticMacConflictEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMacConflictEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMacConflictEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMacConflictEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMacConflictEvent_Def.__bases__: + bases = list(ns0.VmMacConflictEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMacConflictEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmBeingDeployedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmBeingDeployedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmBeingDeployedEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"srcTemplate"), aname="_srcTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmBeingDeployedEvent_Def.__bases__: + bases = list(ns0.VmBeingDeployedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmBeingDeployedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDeployFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDeployFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDeployFailedEvent_Def.schema + TClist = [GTD("urn:vim25","EntityEventArgument",lazy=True)(pname=(ns,"destDatastore"), aname="_destDatastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDeployFailedEvent_Def.__bases__: + bases = list(ns0.VmDeployFailedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDeployFailedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDeployedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDeployedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDeployedEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"srcTemplate"), aname="_srcTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDeployedEvent_Def.__bases__: + bases = list(ns0.VmDeployedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDeployedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMacChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMacChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMacChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"oldMac"), aname="_oldMac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newMac"), aname="_newMac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMacChangedEvent_Def.__bases__: + bases = list(ns0.VmMacChangedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMacChangedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMacAssignedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMacAssignedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMacAssignedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMacAssignedEvent_Def.__bases__: + bases = list(ns0.VmMacAssignedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMacAssignedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmUuidConflictEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmUuidConflictEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmUuidConflictEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmUuidConflictEvent_Def.__bases__: + bases = list(ns0.VmUuidConflictEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmUuidConflictEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmInstanceUuidConflictEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmInstanceUuidConflictEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmInstanceUuidConflictEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmInstanceUuidConflictEvent_Def.__bases__: + bases = list(ns0.VmInstanceUuidConflictEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmInstanceUuidConflictEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmBeingMigratedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmBeingMigratedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmBeingMigratedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmBeingMigratedEvent_Def.__bases__: + bases = list(ns0.VmBeingMigratedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmBeingMigratedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedMigrateEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedMigrateEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedMigrateEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedMigrateEvent_Def.__bases__: + bases = list(ns0.VmFailedMigrateEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedMigrateEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMigratedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMigratedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMigratedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"sourceHost"), aname="_sourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMigratedEvent_Def.__bases__: + bases = list(ns0.VmMigratedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMigratedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmUnsupportedStartingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmUnsupportedStartingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmUnsupportedStartingEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmStartingEvent_Def not in ns0.VmUnsupportedStartingEvent_Def.__bases__: + bases = list(ns0.VmUnsupportedStartingEvent_Def.__bases__) + bases.insert(0, ns0.VmStartingEvent_Def) + ns0.VmUnsupportedStartingEvent_Def.__bases__ = tuple(bases) + + ns0.VmStartingEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsVmMigratedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsVmMigratedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsVmMigratedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmMigratedEvent_Def not in ns0.DrsVmMigratedEvent_Def.__bases__: + bases = list(ns0.DrsVmMigratedEvent_Def.__bases__) + bases.insert(0, ns0.VmMigratedEvent_Def) + ns0.DrsVmMigratedEvent_Def.__bases__ = tuple(bases) + + ns0.VmMigratedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsVmPoweredOnEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsVmPoweredOnEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsVmPoweredOnEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmPoweredOnEvent_Def not in ns0.DrsVmPoweredOnEvent_Def.__bases__: + bases = list(ns0.DrsVmPoweredOnEvent_Def.__bases__) + bases.insert(0, ns0.VmPoweredOnEvent_Def) + ns0.DrsVmPoweredOnEvent_Def.__bases__ = tuple(bases) + + ns0.VmPoweredOnEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRelocateSpecEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRelocateSpecEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRelocateSpecEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRelocateSpecEvent_Def.__bases__: + bases = list(ns0.VmRelocateSpecEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRelocateSpecEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmBeingRelocatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmBeingRelocatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmBeingRelocatedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmRelocateSpecEvent_Def not in ns0.VmBeingRelocatedEvent_Def.__bases__: + bases = list(ns0.VmBeingRelocatedEvent_Def.__bases__) + bases.insert(0, ns0.VmRelocateSpecEvent_Def) + ns0.VmBeingRelocatedEvent_Def.__bases__ = tuple(bases) + + ns0.VmRelocateSpecEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRelocatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRelocatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRelocatedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"sourceHost"), aname="_sourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmRelocateSpecEvent_Def not in ns0.VmRelocatedEvent_Def.__bases__: + bases = list(ns0.VmRelocatedEvent_Def.__bases__) + bases.insert(0, ns0.VmRelocateSpecEvent_Def) + ns0.VmRelocatedEvent_Def.__bases__ = tuple(bases) + + ns0.VmRelocateSpecEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRelocateFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRelocateFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRelocateFailedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmRelocateSpecEvent_Def not in ns0.VmRelocateFailedEvent_Def.__bases__: + bases = list(ns0.VmRelocateFailedEvent_Def.__bases__) + bases.insert(0, ns0.VmRelocateSpecEvent_Def) + ns0.VmRelocateFailedEvent_Def.__bases__ = tuple(bases) + + ns0.VmRelocateSpecEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmEmigratingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmEmigratingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmEmigratingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmEmigratingEvent_Def.__bases__: + bases = list(ns0.VmEmigratingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmEmigratingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmCloneEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmCloneEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmCloneEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmCloneEvent_Def.__bases__: + bases = list(ns0.VmCloneEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmCloneEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmBeingClonedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmBeingClonedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmBeingClonedEvent_Def.schema + TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"destFolder"), aname="_destFolder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmCloneEvent_Def not in ns0.VmBeingClonedEvent_Def.__bases__: + bases = list(ns0.VmBeingClonedEvent_Def.__bases__) + bases.insert(0, ns0.VmCloneEvent_Def) + ns0.VmBeingClonedEvent_Def.__bases__ = tuple(bases) + + ns0.VmCloneEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmCloneFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmCloneFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmCloneFailedEvent_Def.schema + TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"destFolder"), aname="_destFolder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmCloneEvent_Def not in ns0.VmCloneFailedEvent_Def.__bases__: + bases = list(ns0.VmCloneFailedEvent_Def.__bases__) + bases.insert(0, ns0.VmCloneEvent_Def) + ns0.VmCloneFailedEvent_Def.__bases__ = tuple(bases) + + ns0.VmCloneEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmClonedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmClonedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmClonedEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"sourceVm"), aname="_sourceVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmCloneEvent_Def not in ns0.VmClonedEvent_Def.__bases__: + bases = list(ns0.VmClonedEvent_Def.__bases__) + bases.insert(0, ns0.VmCloneEvent_Def) + ns0.VmClonedEvent_Def.__bases__ = tuple(bases) + + ns0.VmCloneEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmResourceReallocatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmResourceReallocatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmResourceReallocatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmResourceReallocatedEvent_Def.__bases__: + bases = list(ns0.VmResourceReallocatedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmResourceReallocatedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRenamedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRenamedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRenamedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRenamedEvent_Def.__bases__: + bases = list(ns0.VmRenamedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRenamedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDateRolledBackEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDateRolledBackEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDateRolledBackEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDateRolledBackEvent_Def.__bases__: + bases = list(ns0.VmDateRolledBackEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDateRolledBackEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmNoNetworkAccessEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmNoNetworkAccessEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmNoNetworkAccessEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmNoNetworkAccessEvent_Def.__bases__: + bases = list(ns0.VmNoNetworkAccessEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmNoNetworkAccessEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDiskFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDiskFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDiskFailedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"disk"), aname="_disk", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDiskFailedEvent_Def.__bases__: + bases = list(ns0.VmDiskFailedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDiskFailedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedToPowerOnEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedToPowerOnEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedToPowerOnEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedToPowerOnEvent_Def.__bases__: + bases = list(ns0.VmFailedToPowerOnEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedToPowerOnEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedToPowerOffEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedToPowerOffEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedToPowerOffEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedToPowerOffEvent_Def.__bases__: + bases = list(ns0.VmFailedToPowerOffEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedToPowerOffEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedToSuspendEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedToSuspendEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedToSuspendEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedToSuspendEvent_Def.__bases__: + bases = list(ns0.VmFailedToSuspendEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedToSuspendEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedToResetEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedToResetEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedToResetEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedToResetEvent_Def.__bases__: + bases = list(ns0.VmFailedToResetEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedToResetEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedToShutdownGuestEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedToShutdownGuestEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedToShutdownGuestEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedToShutdownGuestEvent_Def.__bases__: + bases = list(ns0.VmFailedToShutdownGuestEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedToShutdownGuestEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedToRebootGuestEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedToRebootGuestEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedToRebootGuestEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedToRebootGuestEvent_Def.__bases__: + bases = list(ns0.VmFailedToRebootGuestEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedToRebootGuestEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedToStandbyGuestEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedToStandbyGuestEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedToStandbyGuestEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedToStandbyGuestEvent_Def.__bases__: + bases = list(ns0.VmFailedToStandbyGuestEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedToStandbyGuestEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRemovedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRemovedEvent_Def.__bases__: + bases = list(ns0.VmRemovedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmGuestShutdownEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmGuestShutdownEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmGuestShutdownEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmGuestShutdownEvent_Def.__bases__: + bases = list(ns0.VmGuestShutdownEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmGuestShutdownEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmGuestRebootEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmGuestRebootEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmGuestRebootEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmGuestRebootEvent_Def.__bases__: + bases = list(ns0.VmGuestRebootEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmGuestRebootEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmGuestStandbyEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmGuestStandbyEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmGuestStandbyEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmGuestStandbyEvent_Def.__bases__: + bases = list(ns0.VmGuestStandbyEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmGuestStandbyEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmUpgradingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmUpgradingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmUpgradingEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmUpgradingEvent_Def.__bases__: + bases = list(ns0.VmUpgradingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmUpgradingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmUpgradeCompleteEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmUpgradeCompleteEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmUpgradeCompleteEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmUpgradeCompleteEvent_Def.__bases__: + bases = list(ns0.VmUpgradeCompleteEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmUpgradeCompleteEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmUpgradeFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmUpgradeFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmUpgradeFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmUpgradeFailedEvent_Def.__bases__: + bases = list(ns0.VmUpgradeFailedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmUpgradeFailedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRestartedOnAlternateHostEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRestartedOnAlternateHostEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRestartedOnAlternateHostEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"sourceHost"), aname="_sourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmPoweredOnEvent_Def not in ns0.VmRestartedOnAlternateHostEvent_Def.__bases__: + bases = list(ns0.VmRestartedOnAlternateHostEvent_Def.__bases__) + bases.insert(0, ns0.VmPoweredOnEvent_Def) + ns0.VmRestartedOnAlternateHostEvent_Def.__bases__ = tuple(bases) + + ns0.VmPoweredOnEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmReconfiguredEvent_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmReconfiguredEvent_Def.__bases__: + bases = list(ns0.VmReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMessageEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMessageEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMessageEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"messageInfo"), aname="_messageInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMessageEvent_Def.__bases__: + bases = list(ns0.VmMessageEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMessageEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMessageWarningEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMessageWarningEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMessageWarningEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"messageInfo"), aname="_messageInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMessageWarningEvent_Def.__bases__: + bases = list(ns0.VmMessageWarningEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMessageWarningEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMessageErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMessageErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMessageErrorEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"messageInfo"), aname="_messageInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMessageErrorEvent_Def.__bases__: + bases = list(ns0.VmMessageErrorEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMessageErrorEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigMissingEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigMissingEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigMissingEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmConfigMissingEvent_Def.__bases__: + bases = list(ns0.VmConfigMissingEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmConfigMissingEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmPowerOffOnIsolationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmPowerOffOnIsolationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmPowerOffOnIsolationEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"isolatedHost"), aname="_isolatedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmPoweredOffEvent_Def not in ns0.VmPowerOffOnIsolationEvent_Def.__bases__: + bases = list(ns0.VmPowerOffOnIsolationEvent_Def.__bases__) + bases.insert(0, ns0.VmPoweredOffEvent_Def) + ns0.VmPowerOffOnIsolationEvent_Def.__bases__ = tuple(bases) + + ns0.VmPoweredOffEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmShutdownOnIsolationEventOperation_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VmShutdownOnIsolationEventOperation") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VmShutdownOnIsolationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmShutdownOnIsolationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmShutdownOnIsolationEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"isolatedHost"), aname="_isolatedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"shutdownResult"), aname="_shutdownResult", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmPoweredOffEvent_Def not in ns0.VmShutdownOnIsolationEvent_Def.__bases__: + bases = list(ns0.VmShutdownOnIsolationEvent_Def.__bases__) + bases.insert(0, ns0.VmPoweredOffEvent_Def) + ns0.VmShutdownOnIsolationEvent_Def.__bases__ = tuple(bases) + + ns0.VmPoweredOffEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailoverFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailoverFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailoverFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailoverFailed_Def.__bases__: + bases = list(ns0.VmFailoverFailed_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailoverFailed_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDasBeingResetEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDasBeingResetEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDasBeingResetEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDasBeingResetEvent_Def.__bases__: + bases = list(ns0.VmDasBeingResetEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDasBeingResetEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDasResetFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDasResetFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDasResetFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDasResetFailedEvent_Def.__bases__: + bases = list(ns0.VmDasResetFailedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDasResetFailedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMaxRestartCountReached_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMaxRestartCountReached") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMaxRestartCountReached_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMaxRestartCountReached_Def.__bases__: + bases = list(ns0.VmMaxRestartCountReached_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMaxRestartCountReached_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmMaxFTRestartCountReached_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmMaxFTRestartCountReached") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmMaxFTRestartCountReached_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmMaxFTRestartCountReached_Def.__bases__: + bases = list(ns0.VmMaxFTRestartCountReached_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmMaxFTRestartCountReached_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDasBeingResetWithScreenshotEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDasBeingResetWithScreenshotEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDasBeingResetWithScreenshotEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"screenshotFilePath"), aname="_screenshotFilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmDasBeingResetEvent_Def not in ns0.VmDasBeingResetWithScreenshotEvent_Def.__bases__: + bases = list(ns0.VmDasBeingResetWithScreenshotEvent_Def.__bases__) + bases.insert(0, ns0.VmDasBeingResetEvent_Def) + ns0.VmDasBeingResetWithScreenshotEvent_Def.__bases__ = tuple(bases) + + ns0.VmDasBeingResetEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotEnoughResourcesToStartVmEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotEnoughResourcesToStartVmEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotEnoughResourcesToStartVmEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.NotEnoughResourcesToStartVmEvent_Def.__bases__: + bases = list(ns0.NotEnoughResourcesToStartVmEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.NotEnoughResourcesToStartVmEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmUuidAssignedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmUuidAssignedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmUuidAssignedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmUuidAssignedEvent_Def.__bases__: + bases = list(ns0.VmUuidAssignedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmUuidAssignedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmInstanceUuidAssignedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmInstanceUuidAssignedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmInstanceUuidAssignedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmInstanceUuidAssignedEvent_Def.__bases__: + bases = list(ns0.VmInstanceUuidAssignedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmInstanceUuidAssignedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmUuidChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmUuidChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmUuidChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldUuid"), aname="_oldUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newUuid"), aname="_newUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmUuidChangedEvent_Def.__bases__: + bases = list(ns0.VmUuidChangedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmUuidChangedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmInstanceUuidChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmInstanceUuidChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmInstanceUuidChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldInstanceUuid"), aname="_oldInstanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newInstanceUuid"), aname="_newInstanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmInstanceUuidChangedEvent_Def.__bases__: + bases = list(ns0.VmInstanceUuidChangedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmInstanceUuidChangedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmWwnConflictEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmWwnConflictEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmWwnConflictEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVms"), aname="_conflictedVms", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"conflictedHosts"), aname="_conflictedHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"wwn"), aname="_wwn", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmWwnConflictEvent_Def.__bases__: + bases = list(ns0.VmWwnConflictEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmWwnConflictEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmAcquiredMksTicketEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmAcquiredMksTicketEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmAcquiredMksTicketEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmAcquiredMksTicketEvent_Def.__bases__: + bases = list(ns0.VmAcquiredMksTicketEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmAcquiredMksTicketEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostWwnConflictEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostWwnConflictEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostWwnConflictEvent_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVms"), aname="_conflictedVms", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"conflictedHosts"), aname="_conflictedHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"wwn"), aname="_wwn", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostWwnConflictEvent_Def.__bases__: + bases = list(ns0.HostWwnConflictEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostWwnConflictEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmWwnAssignedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmWwnAssignedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmWwnAssignedEvent_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"nodeWwns"), aname="_nodeWwns", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"portWwns"), aname="_portWwns", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmWwnAssignedEvent_Def.__bases__: + bases = list(ns0.VmWwnAssignedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmWwnAssignedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmWwnChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmWwnChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmWwnChangedEvent_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"oldNodeWwns"), aname="_oldNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"oldPortWwns"), aname="_oldPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newNodeWwns"), aname="_newNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newPortWwns"), aname="_newPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmWwnChangedEvent_Def.__bases__: + bases = list(ns0.VmWwnChangedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmWwnChangedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSecondaryAddedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSecondaryAddedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSecondaryAddedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmSecondaryAddedEvent_Def.__bases__: + bases = list(ns0.VmSecondaryAddedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmSecondaryAddedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFaultToleranceTurnedOffEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFaultToleranceTurnedOffEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFaultToleranceTurnedOffEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFaultToleranceTurnedOffEvent_Def.__bases__: + bases = list(ns0.VmFaultToleranceTurnedOffEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFaultToleranceTurnedOffEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFaultToleranceStateChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFaultToleranceStateChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFaultToleranceStateChangedEvent_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFaultToleranceState",lazy=True)(pname=(ns,"oldState"), aname="_oldState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFaultToleranceState",lazy=True)(pname=(ns,"newState"), aname="_newState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFaultToleranceStateChangedEvent_Def.__bases__: + bases = list(ns0.VmFaultToleranceStateChangedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFaultToleranceStateChangedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSecondaryDisabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSecondaryDisabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSecondaryDisabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmSecondaryDisabledEvent_Def.__bases__: + bases = list(ns0.VmSecondaryDisabledEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmSecondaryDisabledEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSecondaryDisabledBySystemEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSecondaryDisabledBySystemEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSecondaryDisabledBySystemEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmSecondaryDisabledBySystemEvent_Def.__bases__: + bases = list(ns0.VmSecondaryDisabledBySystemEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmSecondaryDisabledBySystemEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSecondaryEnabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSecondaryEnabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSecondaryEnabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmSecondaryEnabledEvent_Def.__bases__: + bases = list(ns0.VmSecondaryEnabledEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmSecondaryEnabledEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmStartingSecondaryEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmStartingSecondaryEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmStartingSecondaryEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmStartingSecondaryEvent_Def.__bases__: + bases = list(ns0.VmStartingSecondaryEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmStartingSecondaryEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSecondaryStartedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSecondaryStartedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSecondaryStartedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmSecondaryStartedEvent_Def.__bases__: + bases = list(ns0.VmSecondaryStartedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmSecondaryStartedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedUpdatingSecondaryConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedUpdatingSecondaryConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedUpdatingSecondaryConfig_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedUpdatingSecondaryConfig_Def.__bases__: + bases = list(ns0.VmFailedUpdatingSecondaryConfig_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedUpdatingSecondaryConfig_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedStartingSecondaryEventFailureReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VmFailedStartingSecondaryEventFailureReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VmFailedStartingSecondaryEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedStartingSecondaryEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedStartingSecondaryEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedStartingSecondaryEvent_Def.__bases__: + bases = list(ns0.VmFailedStartingSecondaryEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedStartingSecondaryEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmTimedoutStartingSecondaryEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmTimedoutStartingSecondaryEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmTimedoutStartingSecondaryEvent_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"timeout"), aname="_timeout", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmTimedoutStartingSecondaryEvent_Def.__bases__: + bases = list(ns0.VmTimedoutStartingSecondaryEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmTimedoutStartingSecondaryEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmNoCompatibleHostForSecondaryEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmNoCompatibleHostForSecondaryEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmNoCompatibleHostForSecondaryEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmNoCompatibleHostForSecondaryEvent_Def.__bases__: + bases = list(ns0.VmNoCompatibleHostForSecondaryEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmNoCompatibleHostForSecondaryEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmPrimaryFailoverEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmPrimaryFailoverEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmPrimaryFailoverEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmPrimaryFailoverEvent_Def.__bases__: + bases = list(ns0.VmPrimaryFailoverEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmPrimaryFailoverEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFaultToleranceVmTerminatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFaultToleranceVmTerminatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFaultToleranceVmTerminatedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFaultToleranceVmTerminatedEvent_Def.__bases__: + bases = list(ns0.VmFaultToleranceVmTerminatedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFaultToleranceVmTerminatedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostWwnChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostWwnChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostWwnChangedEvent_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"oldNodeWwns"), aname="_oldNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"oldPortWwns"), aname="_oldPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newNodeWwns"), aname="_newNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newPortWwns"), aname="_newPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostWwnChangedEvent_Def.__bases__: + bases = list(ns0.HostWwnChangedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostWwnChangedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostAdminDisableEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostAdminDisableEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostAdminDisableEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostAdminDisableEvent_Def.__bases__: + bases = list(ns0.HostAdminDisableEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostAdminDisableEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostAdminEnableEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostAdminEnableEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostAdminEnableEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostAdminEnableEvent_Def.__bases__: + bases = list(ns0.HostAdminEnableEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostAdminEnableEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostEnableAdminFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostEnableAdminFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostEnableAdminFailedEvent_Def.schema + TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"permissions"), aname="_permissions", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.HostEnableAdminFailedEvent_Def.__bases__: + bases = list(ns0.HostEnableAdminFailedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.HostEnableAdminFailedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedRelayoutOnVmfs2DatastoreEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedRelayoutOnVmfs2DatastoreEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.__bases__: + bases = list(ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFailedRelayoutEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFailedRelayoutEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFailedRelayoutEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmFailedRelayoutEvent_Def.__bases__: + bases = list(ns0.VmFailedRelayoutEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmFailedRelayoutEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRelayoutSuccessfulEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRelayoutSuccessfulEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRelayoutSuccessfulEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRelayoutSuccessfulEvent_Def.__bases__: + bases = list(ns0.VmRelayoutSuccessfulEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRelayoutSuccessfulEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmRelayoutUpToDateEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmRelayoutUpToDateEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmRelayoutUpToDateEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmRelayoutUpToDateEvent_Def.__bases__: + bases = list(ns0.VmRelayoutUpToDateEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmRelayoutUpToDateEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConnectedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmConnectedEvent_Def.__bases__: + bases = list(ns0.VmConnectedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmConnectedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmPoweringOnWithCustomizedDVPortEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmPoweringOnWithCustomizedDVPortEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.schema + TClist = [GTD("urn:vim25","VnicPortArgument",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.__bases__: + bases = list(ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDasUpdateErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDasUpdateErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDasUpdateErrorEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDasUpdateErrorEvent_Def.__bases__: + bases = list(ns0.VmDasUpdateErrorEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDasUpdateErrorEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoMaintenanceModeDrsRecommendationForVM_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoMaintenanceModeDrsRecommendationForVM") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoMaintenanceModeDrsRecommendationForVM_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.NoMaintenanceModeDrsRecommendationForVM_Def.__bases__: + bases = list(ns0.NoMaintenanceModeDrsRecommendationForVM_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.NoMaintenanceModeDrsRecommendationForVM_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDasUpdateOkEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDasUpdateOkEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDasUpdateOkEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmDasUpdateOkEvent_Def.__bases__: + bases = list(ns0.VmDasUpdateOkEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmDasUpdateOkEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskEvent_Def.schema + TClist = [GTD("urn:vim25","ScheduledTaskEventArgument",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.ScheduledTaskEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.ScheduledTaskEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskCreatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskCreatedEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskCreatedEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskStartedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskStartedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskStartedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskStartedEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskStartedEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskStartedEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskRemovedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskRemovedEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskRemovedEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskReconfiguredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskReconfiguredEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskCompletedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskCompletedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskCompletedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskCompletedEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskCompletedEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskCompletedEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskFailedEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskFailedEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskFailedEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskFailedEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskEmailCompletedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskEmailCompletedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskEmailCompletedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskEmailCompletedEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskEmailCompletedEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskEmailCompletedEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskEmailFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskEmailFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskEmailFailedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskEmailFailedEvent_Def.__bases__: + bases = list(ns0.ScheduledTaskEmailFailedEvent_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskEvent_Def) + ns0.ScheduledTaskEmailFailedEvent_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmEvent_Def.schema + TClist = [GTD("urn:vim25","AlarmEventArgument",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.AlarmEvent_Def.__bases__: + bases = list(ns0.AlarmEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.AlarmEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmCreatedEvent_Def.__bases__: + bases = list(ns0.AlarmCreatedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmStatusChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmStatusChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmStatusChangedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"from"), aname="_from", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmStatusChangedEvent_Def.__bases__: + bases = list(ns0.AlarmStatusChangedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmStatusChangedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmActionTriggeredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmActionTriggeredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmActionTriggeredEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmActionTriggeredEvent_Def.__bases__: + bases = list(ns0.AlarmActionTriggeredEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmActionTriggeredEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmEmailCompletedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmEmailCompletedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmEmailCompletedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmEmailCompletedEvent_Def.__bases__: + bases = list(ns0.AlarmEmailCompletedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmEmailCompletedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmEmailFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmEmailFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmEmailFailedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmEmailFailedEvent_Def.__bases__: + bases = list(ns0.AlarmEmailFailedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmEmailFailedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmSnmpCompletedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmSnmpCompletedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmSnmpCompletedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmSnmpCompletedEvent_Def.__bases__: + bases = list(ns0.AlarmSnmpCompletedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmSnmpCompletedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmSnmpFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmSnmpFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmSnmpFailedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmSnmpFailedEvent_Def.__bases__: + bases = list(ns0.AlarmSnmpFailedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmSnmpFailedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmScriptCompleteEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmScriptCompleteEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmScriptCompleteEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"script"), aname="_script", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmScriptCompleteEvent_Def.__bases__: + bases = list(ns0.AlarmScriptCompleteEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmScriptCompleteEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmScriptFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmScriptFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmScriptFailedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"script"), aname="_script", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmScriptFailedEvent_Def.__bases__: + bases = list(ns0.AlarmScriptFailedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmScriptFailedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmRemovedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmRemovedEvent_Def.__bases__: + bases = list(ns0.AlarmRemovedEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmReconfiguredEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AlarmEvent_Def not in ns0.AlarmReconfiguredEvent_Def.__bases__: + bases = list(ns0.AlarmReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.AlarmEvent_Def) + ns0.AlarmReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomFieldEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.CustomFieldEvent_Def.__bases__: + bases = list(ns0.CustomFieldEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.CustomFieldEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomFieldDefEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldDefEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldDefEvent_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"fieldKey"), aname="_fieldKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomFieldEvent_Def not in ns0.CustomFieldDefEvent_Def.__bases__: + bases = list(ns0.CustomFieldDefEvent_Def.__bases__) + bases.insert(0, ns0.CustomFieldEvent_Def) + ns0.CustomFieldDefEvent_Def.__bases__ = tuple(bases) + + ns0.CustomFieldEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomFieldDefAddedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldDefAddedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldDefAddedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomFieldDefEvent_Def not in ns0.CustomFieldDefAddedEvent_Def.__bases__: + bases = list(ns0.CustomFieldDefAddedEvent_Def.__bases__) + bases.insert(0, ns0.CustomFieldDefEvent_Def) + ns0.CustomFieldDefAddedEvent_Def.__bases__ = tuple(bases) + + ns0.CustomFieldDefEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomFieldDefRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldDefRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldDefRemovedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomFieldDefEvent_Def not in ns0.CustomFieldDefRemovedEvent_Def.__bases__: + bases = list(ns0.CustomFieldDefRemovedEvent_Def.__bases__) + bases.insert(0, ns0.CustomFieldDefEvent_Def) + ns0.CustomFieldDefRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.CustomFieldDefEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomFieldDefRenamedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldDefRenamedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldDefRenamedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomFieldDefEvent_Def not in ns0.CustomFieldDefRenamedEvent_Def.__bases__: + bases = list(ns0.CustomFieldDefRenamedEvent_Def.__bases__) + bases.insert(0, ns0.CustomFieldDefEvent_Def) + ns0.CustomFieldDefRenamedEvent_Def.__bases__ = tuple(bases) + + ns0.CustomFieldDefEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomFieldValueChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomFieldValueChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomFieldValueChangedEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"fieldKey"), aname="_fieldKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomFieldEvent_Def not in ns0.CustomFieldValueChangedEvent_Def.__bases__: + bases = list(ns0.CustomFieldValueChangedEvent_Def.__bases__) + bases.insert(0, ns0.CustomFieldEvent_Def) + ns0.CustomFieldValueChangedEvent_Def.__bases__ = tuple(bases) + + ns0.CustomFieldEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AuthorizationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AuthorizationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AuthorizationEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.AuthorizationEvent_Def.__bases__: + bases = list(ns0.AuthorizationEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.AuthorizationEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PermissionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PermissionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PermissionEvent_Def.schema + TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AuthorizationEvent_Def not in ns0.PermissionEvent_Def.__bases__: + bases = list(ns0.PermissionEvent_Def.__bases__) + bases.insert(0, ns0.AuthorizationEvent_Def) + ns0.PermissionEvent_Def.__bases__ = tuple(bases) + + ns0.AuthorizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PermissionAddedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PermissionAddedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PermissionAddedEvent_Def.schema + TClist = [GTD("urn:vim25","RoleEventArgument",lazy=True)(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"propagate"), aname="_propagate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PermissionEvent_Def not in ns0.PermissionAddedEvent_Def.__bases__: + bases = list(ns0.PermissionAddedEvent_Def.__bases__) + bases.insert(0, ns0.PermissionEvent_Def) + ns0.PermissionAddedEvent_Def.__bases__ = tuple(bases) + + ns0.PermissionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PermissionUpdatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PermissionUpdatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PermissionUpdatedEvent_Def.schema + TClist = [GTD("urn:vim25","RoleEventArgument",lazy=True)(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"propagate"), aname="_propagate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PermissionEvent_Def not in ns0.PermissionUpdatedEvent_Def.__bases__: + bases = list(ns0.PermissionUpdatedEvent_Def.__bases__) + bases.insert(0, ns0.PermissionEvent_Def) + ns0.PermissionUpdatedEvent_Def.__bases__ = tuple(bases) + + ns0.PermissionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PermissionRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PermissionRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PermissionRemovedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PermissionEvent_Def not in ns0.PermissionRemovedEvent_Def.__bases__: + bases = list(ns0.PermissionRemovedEvent_Def.__bases__) + bases.insert(0, ns0.PermissionEvent_Def) + ns0.PermissionRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.PermissionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RoleEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RoleEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RoleEvent_Def.schema + TClist = [GTD("urn:vim25","RoleEventArgument",lazy=True)(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.AuthorizationEvent_Def not in ns0.RoleEvent_Def.__bases__: + bases = list(ns0.RoleEvent_Def.__bases__) + bases.insert(0, ns0.AuthorizationEvent_Def) + ns0.RoleEvent_Def.__bases__ = tuple(bases) + + ns0.AuthorizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RoleAddedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RoleAddedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RoleAddedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"privilegeList"), aname="_privilegeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RoleEvent_Def not in ns0.RoleAddedEvent_Def.__bases__: + bases = list(ns0.RoleAddedEvent_Def.__bases__) + bases.insert(0, ns0.RoleEvent_Def) + ns0.RoleAddedEvent_Def.__bases__ = tuple(bases) + + ns0.RoleEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RoleUpdatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RoleUpdatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RoleUpdatedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"privilegeList"), aname="_privilegeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RoleEvent_Def not in ns0.RoleUpdatedEvent_Def.__bases__: + bases = list(ns0.RoleUpdatedEvent_Def.__bases__) + bases.insert(0, ns0.RoleEvent_Def) + ns0.RoleUpdatedEvent_Def.__bases__ = tuple(bases) + + ns0.RoleEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RoleRemovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RoleRemovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RoleRemovedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RoleEvent_Def not in ns0.RoleRemovedEvent_Def.__bases__: + bases = list(ns0.RoleRemovedEvent_Def.__bases__) + bases.insert(0, ns0.RoleEvent_Def) + ns0.RoleRemovedEvent_Def.__bases__ = tuple(bases) + + ns0.RoleEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.DatastoreEvent_Def.__bases__: + bases = list(ns0.DatastoreEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.DatastoreEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreDestroyedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreDestroyedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreDestroyedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreEvent_Def not in ns0.DatastoreDestroyedEvent_Def.__bases__: + bases = list(ns0.DatastoreDestroyedEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreEvent_Def) + ns0.DatastoreDestroyedEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreRenamedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreRenamedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreRenamedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreEvent_Def not in ns0.DatastoreRenamedEvent_Def.__bases__: + bases = list(ns0.DatastoreRenamedEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreEvent_Def) + ns0.DatastoreRenamedEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreCapacityIncreasedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreCapacityIncreasedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreCapacityIncreasedEvent_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"oldCapacity"), aname="_oldCapacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newCapacity"), aname="_newCapacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreEvent_Def not in ns0.DatastoreCapacityIncreasedEvent_Def.__bases__: + bases = list(ns0.DatastoreCapacityIncreasedEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreEvent_Def) + ns0.DatastoreCapacityIncreasedEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreDuplicatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreDuplicatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreDuplicatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreEvent_Def not in ns0.DatastoreDuplicatedEvent_Def.__bases__: + bases = list(ns0.DatastoreDuplicatedEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreEvent_Def) + ns0.DatastoreDuplicatedEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreFileEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreFileEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreFileEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"targetFile"), aname="_targetFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreEvent_Def not in ns0.DatastoreFileEvent_Def.__bases__: + bases = list(ns0.DatastoreFileEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreEvent_Def) + ns0.DatastoreFileEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreFileCopiedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreFileCopiedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreFileCopiedEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"sourceDatastore"), aname="_sourceDatastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceFile"), aname="_sourceFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreFileEvent_Def not in ns0.DatastoreFileCopiedEvent_Def.__bases__: + bases = list(ns0.DatastoreFileCopiedEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreFileEvent_Def) + ns0.DatastoreFileCopiedEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreFileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreFileMovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreFileMovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreFileMovedEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"sourceDatastore"), aname="_sourceDatastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceFile"), aname="_sourceFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreFileEvent_Def not in ns0.DatastoreFileMovedEvent_Def.__bases__: + bases = list(ns0.DatastoreFileMovedEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreFileEvent_Def) + ns0.DatastoreFileMovedEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreFileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreFileDeletedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreFileDeletedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreFileDeletedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreFileEvent_Def not in ns0.DatastoreFileDeletedEvent_Def.__bases__: + bases = list(ns0.DatastoreFileDeletedEvent_Def.__bases__) + bases.insert(0, ns0.DatastoreFileEvent_Def) + ns0.DatastoreFileDeletedEvent_Def.__bases__ = tuple(bases) + + ns0.DatastoreFileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskEvent_Def.schema + TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.TaskEvent_Def.__bases__: + bases = list(ns0.TaskEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.TaskEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskTimeoutEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskTimeoutEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskTimeoutEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskEvent_Def not in ns0.TaskTimeoutEvent_Def.__bases__: + bases = list(ns0.TaskTimeoutEvent_Def.__bases__) + bases.insert(0, ns0.TaskEvent_Def) + ns0.TaskTimeoutEvent_Def.__bases__ = tuple(bases) + + ns0.TaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.LicenseEvent_Def.__bases__: + bases = list(ns0.LicenseEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.LicenseEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ServerLicenseExpiredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ServerLicenseExpiredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ServerLicenseExpiredEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"product"), aname="_product", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.ServerLicenseExpiredEvent_Def.__bases__: + bases = list(ns0.ServerLicenseExpiredEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.ServerLicenseExpiredEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostLicenseExpiredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostLicenseExpiredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostLicenseExpiredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.HostLicenseExpiredEvent_Def.__bases__: + bases = list(ns0.HostLicenseExpiredEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.HostLicenseExpiredEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionLicenseExpiredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionLicenseExpiredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionLicenseExpiredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.VMotionLicenseExpiredEvent_Def.__bases__: + bases = list(ns0.VMotionLicenseExpiredEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.VMotionLicenseExpiredEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoLicenseEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoLicenseEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoLicenseEvent_Def.schema + TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.NoLicenseEvent_Def.__bases__: + bases = list(ns0.NoLicenseEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.NoLicenseEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseServerUnavailableEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseServerUnavailableEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseServerUnavailableEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.LicenseServerUnavailableEvent_Def.__bases__: + bases = list(ns0.LicenseServerUnavailableEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.LicenseServerUnavailableEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseServerAvailableEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseServerAvailableEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseServerAvailableEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.LicenseServerAvailableEvent_Def.__bases__: + bases = list(ns0.LicenseServerAvailableEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.LicenseServerAvailableEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseExpiredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseExpiredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseExpiredEvent_Def.schema + TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.LicenseExpiredEvent_Def.__bases__: + bases = list(ns0.LicenseExpiredEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.LicenseExpiredEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidEditionEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidEditionEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidEditionEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.InvalidEditionEvent_Def.__bases__: + bases = list(ns0.InvalidEditionEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.InvalidEditionEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInventoryFullEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInventoryFullEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInventoryFullEvent_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.HostInventoryFullEvent_Def.__bases__: + bases = list(ns0.HostInventoryFullEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.HostInventoryFullEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseRestrictedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseRestrictedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseRestrictedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.LicenseRestrictedEvent_Def.__bases__: + bases = list(ns0.LicenseRestrictedEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.LicenseRestrictedEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IncorrectHostInformationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IncorrectHostInformationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IncorrectHostInformationEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.IncorrectHostInformationEvent_Def.__bases__: + bases = list(ns0.IncorrectHostInformationEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.IncorrectHostInformationEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnlicensedVirtualMachinesEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnlicensedVirtualMachinesEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnlicensedVirtualMachinesEvent_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"unlicensed"), aname="_unlicensed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.UnlicensedVirtualMachinesEvent_Def.__bases__: + bases = list(ns0.UnlicensedVirtualMachinesEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.UnlicensedVirtualMachinesEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnlicensedVirtualMachinesFoundEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnlicensedVirtualMachinesFoundEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnlicensedVirtualMachinesFoundEvent_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.UnlicensedVirtualMachinesFoundEvent_Def.__bases__: + bases = list(ns0.UnlicensedVirtualMachinesFoundEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.UnlicensedVirtualMachinesFoundEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AllVirtualMachinesLicensedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AllVirtualMachinesLicensedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AllVirtualMachinesLicensedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.AllVirtualMachinesLicensedEvent_Def.__bases__: + bases = list(ns0.AllVirtualMachinesLicensedEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.AllVirtualMachinesLicensedEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseNonComplianceEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseNonComplianceEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseNonComplianceEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.LicenseEvent_Def not in ns0.LicenseNonComplianceEvent_Def.__bases__: + bases = list(ns0.LicenseNonComplianceEvent_Def.__bases__) + bases.insert(0, ns0.LicenseEvent_Def) + ns0.LicenseNonComplianceEvent_Def.__bases__ = tuple(bases) + + ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.MigrationEvent_Def.__bases__: + bases = list(ns0.MigrationEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.MigrationEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationWarningEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationWarningEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationWarningEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationEvent_Def not in ns0.MigrationWarningEvent_Def.__bases__: + bases = list(ns0.MigrationWarningEvent_Def.__bases__) + bases.insert(0, ns0.MigrationEvent_Def) + ns0.MigrationWarningEvent_Def.__bases__ = tuple(bases) + + ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationErrorEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationEvent_Def not in ns0.MigrationErrorEvent_Def.__bases__: + bases = list(ns0.MigrationErrorEvent_Def.__bases__) + bases.insert(0, ns0.MigrationEvent_Def) + ns0.MigrationErrorEvent_Def.__bases__ = tuple(bases) + + ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationHostWarningEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationHostWarningEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationHostWarningEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationEvent_Def not in ns0.MigrationHostWarningEvent_Def.__bases__: + bases = list(ns0.MigrationHostWarningEvent_Def.__bases__) + bases.insert(0, ns0.MigrationEvent_Def) + ns0.MigrationHostWarningEvent_Def.__bases__ = tuple(bases) + + ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationHostErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationHostErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationHostErrorEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationEvent_Def not in ns0.MigrationHostErrorEvent_Def.__bases__: + bases = list(ns0.MigrationHostErrorEvent_Def.__bases__) + bases.insert(0, ns0.MigrationEvent_Def) + ns0.MigrationHostErrorEvent_Def.__bases__ = tuple(bases) + + ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationResourceWarningEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationResourceWarningEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationResourceWarningEvent_Def.schema + TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"dstPool"), aname="_dstPool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationEvent_Def not in ns0.MigrationResourceWarningEvent_Def.__bases__: + bases = list(ns0.MigrationResourceWarningEvent_Def.__bases__) + bases.insert(0, ns0.MigrationEvent_Def) + ns0.MigrationResourceWarningEvent_Def.__bases__ = tuple(bases) + + ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationResourceErrorEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationResourceErrorEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationResourceErrorEvent_Def.schema + TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"dstPool"), aname="_dstPool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationEvent_Def not in ns0.MigrationResourceErrorEvent_Def.__bases__: + bases = list(ns0.MigrationResourceErrorEvent_Def.__bases__) + bases.insert(0, ns0.MigrationEvent_Def) + ns0.MigrationResourceErrorEvent_Def.__bases__ = tuple(bases) + + ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.ClusterEvent_Def.__bases__: + bases = list(ns0.ClusterEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.ClusterEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasEnabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasEnabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasEnabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasEnabledEvent_Def.__bases__: + bases = list(ns0.DasEnabledEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasEnabledEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasDisabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasDisabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasDisabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasDisabledEvent_Def.__bases__: + bases = list(ns0.DasDisabledEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasDisabledEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasAdmissionControlDisabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasAdmissionControlDisabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasAdmissionControlDisabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasAdmissionControlDisabledEvent_Def.__bases__: + bases = list(ns0.DasAdmissionControlDisabledEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasAdmissionControlDisabledEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasAdmissionControlEnabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasAdmissionControlEnabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasAdmissionControlEnabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasAdmissionControlEnabledEvent_Def.__bases__: + bases = list(ns0.DasAdmissionControlEnabledEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasAdmissionControlEnabledEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasHostFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasHostFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasHostFailedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"failedHost"), aname="_failedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasHostFailedEvent_Def.__bases__: + bases = list(ns0.DasHostFailedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasHostFailedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasHostIsolatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasHostIsolatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasHostIsolatedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"isolatedHost"), aname="_isolatedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasHostIsolatedEvent_Def.__bases__: + bases = list(ns0.DasHostIsolatedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasHostIsolatedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasClusterIsolatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasClusterIsolatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasClusterIsolatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasClusterIsolatedEvent_Def.__bases__: + bases = list(ns0.DasClusterIsolatedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasClusterIsolatedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasAgentUnavailableEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasAgentUnavailableEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasAgentUnavailableEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasAgentUnavailableEvent_Def.__bases__: + bases = list(ns0.DasAgentUnavailableEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasAgentUnavailableEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasAgentFoundEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasAgentFoundEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasAgentFoundEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DasAgentFoundEvent_Def.__bases__: + bases = list(ns0.DasAgentFoundEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DasAgentFoundEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientFailoverResourcesEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientFailoverResourcesEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientFailoverResourcesEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.InsufficientFailoverResourcesEvent_Def.__bases__: + bases = list(ns0.InsufficientFailoverResourcesEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.InsufficientFailoverResourcesEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FailoverLevelRestored_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FailoverLevelRestored") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FailoverLevelRestored_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.FailoverLevelRestored_Def.__bases__: + bases = list(ns0.FailoverLevelRestored_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.FailoverLevelRestored_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterOvercommittedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterOvercommittedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterOvercommittedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.ClusterOvercommittedEvent_Def.__bases__: + bases = list(ns0.ClusterOvercommittedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.ClusterOvercommittedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostOvercommittedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostOvercommittedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostOvercommittedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterOvercommittedEvent_Def not in ns0.HostOvercommittedEvent_Def.__bases__: + bases = list(ns0.HostOvercommittedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterOvercommittedEvent_Def) + ns0.HostOvercommittedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterOvercommittedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterStatusChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterStatusChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterStatusChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldStatus"), aname="_oldStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newStatus"), aname="_newStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.ClusterStatusChangedEvent_Def.__bases__: + bases = list(ns0.ClusterStatusChangedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.ClusterStatusChangedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostStatusChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostStatusChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostStatusChangedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterStatusChangedEvent_Def not in ns0.HostStatusChangedEvent_Def.__bases__: + bases = list(ns0.HostStatusChangedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterStatusChangedEvent_Def) + ns0.HostStatusChangedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterStatusChangedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.ClusterCreatedEvent_Def.__bases__: + bases = list(ns0.ClusterCreatedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.ClusterCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterDestroyedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterDestroyedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterDestroyedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.ClusterDestroyedEvent_Def.__bases__: + bases = list(ns0.ClusterDestroyedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.ClusterDestroyedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsEnabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsEnabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsEnabledEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"behavior"), aname="_behavior", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DrsEnabledEvent_Def.__bases__: + bases = list(ns0.DrsEnabledEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DrsEnabledEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsDisabledEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsDisabledEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsDisabledEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DrsDisabledEvent_Def.__bases__: + bases = list(ns0.DrsDisabledEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DrsDisabledEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterReconfiguredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.ClusterReconfiguredEvent_Def.__bases__: + bases = list(ns0.ClusterReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.ClusterReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostMonitoringStateChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMonitoringStateChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMonitoringStateChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.HostMonitoringStateChangedEvent_Def.__bases__: + bases = list(ns0.HostMonitoringStateChangedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.HostMonitoringStateChangedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmHealthMonitoringStateChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmHealthMonitoringStateChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmHealthMonitoringStateChangedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.VmHealthMonitoringStateChangedEvent_Def.__bases__: + bases = list(ns0.VmHealthMonitoringStateChangedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.VmHealthMonitoringStateChangedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolEvent_Def.schema + TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.ResourcePoolEvent_Def.__bases__: + bases = list(ns0.ResourcePoolEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.ResourcePoolEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolCreatedEvent_Def.__bases__: + bases = list(ns0.ResourcePoolCreatedEvent_Def.__bases__) + bases.insert(0, ns0.ResourcePoolEvent_Def) + ns0.ResourcePoolCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolDestroyedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolDestroyedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolDestroyedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolDestroyedEvent_Def.__bases__: + bases = list(ns0.ResourcePoolDestroyedEvent_Def.__bases__) + bases.insert(0, ns0.ResourcePoolEvent_Def) + ns0.ResourcePoolDestroyedEvent_Def.__bases__ = tuple(bases) + + ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolMovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolMovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolMovedEvent_Def.schema + TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"oldParent"), aname="_oldParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"newParent"), aname="_newParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolMovedEvent_Def.__bases__: + bases = list(ns0.ResourcePoolMovedEvent_Def.__bases__) + bases.insert(0, ns0.ResourcePoolEvent_Def) + ns0.ResourcePoolMovedEvent_Def.__bases__ = tuple(bases) + + ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolReconfiguredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolReconfiguredEvent_Def.__bases__: + bases = list(ns0.ResourcePoolReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.ResourcePoolEvent_Def) + ns0.ResourcePoolReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourceViolatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourceViolatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourceViolatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ResourcePoolEvent_Def not in ns0.ResourceViolatedEvent_Def.__bases__: + bases = list(ns0.ResourceViolatedEvent_Def.__bases__) + bases.insert(0, ns0.ResourcePoolEvent_Def) + ns0.ResourceViolatedEvent_Def.__bases__ = tuple(bases) + + ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmResourcePoolMovedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmResourcePoolMovedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmResourcePoolMovedEvent_Def.schema + TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"oldParent"), aname="_oldParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"newParent"), aname="_newParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.VmResourcePoolMovedEvent_Def.__bases__: + bases = list(ns0.VmResourcePoolMovedEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.VmResourcePoolMovedEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TemplateUpgradeEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TemplateUpgradeEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TemplateUpgradeEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"legacyTemplate"), aname="_legacyTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.TemplateUpgradeEvent_Def.__bases__: + bases = list(ns0.TemplateUpgradeEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.TemplateUpgradeEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TemplateBeingUpgradedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TemplateBeingUpgradedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TemplateBeingUpgradedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TemplateUpgradeEvent_Def not in ns0.TemplateBeingUpgradedEvent_Def.__bases__: + bases = list(ns0.TemplateBeingUpgradedEvent_Def.__bases__) + bases.insert(0, ns0.TemplateUpgradeEvent_Def) + ns0.TemplateBeingUpgradedEvent_Def.__bases__ = tuple(bases) + + ns0.TemplateUpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TemplateUpgradeFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TemplateUpgradeFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TemplateUpgradeFailedEvent_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TemplateUpgradeEvent_Def not in ns0.TemplateUpgradeFailedEvent_Def.__bases__: + bases = list(ns0.TemplateUpgradeFailedEvent_Def.__bases__) + bases.insert(0, ns0.TemplateUpgradeEvent_Def) + ns0.TemplateUpgradeFailedEvent_Def.__bases__ = tuple(bases) + + ns0.TemplateUpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TemplateUpgradedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TemplateUpgradedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TemplateUpgradedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TemplateUpgradeEvent_Def not in ns0.TemplateUpgradedEvent_Def.__bases__: + bases = list(ns0.TemplateUpgradedEvent_Def.__bases__) + bases.insert(0, ns0.TemplateUpgradeEvent_Def) + ns0.TemplateUpgradedEvent_Def.__bases__ = tuple(bases) + + ns0.TemplateUpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"logLocation"), aname="_logLocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmEvent_Def not in ns0.CustomizationEvent_Def.__bases__: + bases = list(ns0.CustomizationEvent_Def.__bases__) + bases.insert(0, ns0.VmEvent_Def) + ns0.CustomizationEvent_Def.__bases__ = tuple(bases) + + ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationStartedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationStartedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationStartedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationEvent_Def not in ns0.CustomizationStartedEvent_Def.__bases__: + bases = list(ns0.CustomizationStartedEvent_Def.__bases__) + bases.insert(0, ns0.CustomizationEvent_Def) + ns0.CustomizationStartedEvent_Def.__bases__ = tuple(bases) + + ns0.CustomizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationSucceeded_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationSucceeded") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationSucceeded_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationEvent_Def not in ns0.CustomizationSucceeded_Def.__bases__: + bases = list(ns0.CustomizationSucceeded_Def.__bases__) + bases.insert(0, ns0.CustomizationEvent_Def) + ns0.CustomizationSucceeded_Def.__bases__ = tuple(bases) + + ns0.CustomizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationEvent_Def not in ns0.CustomizationFailed_Def.__bases__: + bases = list(ns0.CustomizationFailed_Def.__bases__) + bases.insert(0, ns0.CustomizationEvent_Def) + ns0.CustomizationFailed_Def.__bases__ = tuple(bases) + + ns0.CustomizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationUnknownFailure_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationUnknownFailure") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationUnknownFailure_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFailed_Def not in ns0.CustomizationUnknownFailure_Def.__bases__: + bases = list(ns0.CustomizationUnknownFailure_Def.__bases__) + bases.insert(0, ns0.CustomizationFailed_Def) + ns0.CustomizationUnknownFailure_Def.__bases__ = tuple(bases) + + ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationSysprepFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationSysprepFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationSysprepFailed_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"sysprepVersion"), aname="_sysprepVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemVersion"), aname="_systemVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFailed_Def not in ns0.CustomizationSysprepFailed_Def.__bases__: + bases = list(ns0.CustomizationSysprepFailed_Def.__bases__) + bases.insert(0, ns0.CustomizationFailed_Def) + ns0.CustomizationSysprepFailed_Def.__bases__ = tuple(bases) + + ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationLinuxIdentityFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationLinuxIdentityFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationLinuxIdentityFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFailed_Def not in ns0.CustomizationLinuxIdentityFailed_Def.__bases__: + bases = list(ns0.CustomizationLinuxIdentityFailed_Def.__bases__) + bases.insert(0, ns0.CustomizationFailed_Def) + ns0.CustomizationLinuxIdentityFailed_Def.__bases__ = tuple(bases) + + ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationNetworkSetupFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationNetworkSetupFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationNetworkSetupFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFailed_Def not in ns0.CustomizationNetworkSetupFailed_Def.__bases__: + bases = list(ns0.CustomizationNetworkSetupFailed_Def.__bases__) + bases.insert(0, ns0.CustomizationFailed_Def) + ns0.CustomizationNetworkSetupFailed_Def.__bases__ = tuple(bases) + + ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LockerMisconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LockerMisconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LockerMisconfiguredEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.LockerMisconfiguredEvent_Def.__bases__: + bases = list(ns0.LockerMisconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.LockerMisconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LockerReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LockerReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LockerReconfiguredEvent_Def.schema + TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"oldDatastore"), aname="_oldDatastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"newDatastore"), aname="_newDatastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.LockerReconfiguredEvent_Def.__bases__: + bases = list(ns0.LockerReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.LockerReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoDatastoresConfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoDatastoresConfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoDatastoresConfiguredEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.NoDatastoresConfiguredEvent_Def.__bases__: + bases = list(ns0.NoDatastoresConfiguredEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.NoDatastoresConfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AdminPasswordNotChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AdminPasswordNotChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AdminPasswordNotChangedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.AdminPasswordNotChangedEvent_Def.__bases__: + bases = list(ns0.AdminPasswordNotChangedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.AdminPasswordNotChangedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VimAccountPasswordChangedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VimAccountPasswordChangedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VimAccountPasswordChangedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostEvent_Def not in ns0.VimAccountPasswordChangedEvent_Def.__bases__: + bases = list(ns0.VimAccountPasswordChangedEvent_Def.__bases__) + bases.insert(0, ns0.HostEvent_Def) + ns0.VimAccountPasswordChangedEvent_Def.__bases__ = tuple(bases) + + ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.DvsEvent_Def.__bases__: + bases = list(ns0.DvsEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.DvsEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsCreatedEvent_Def.schema + TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsCreatedEvent_Def.__bases__: + bases = list(ns0.DvsCreatedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsRenamedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsRenamedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsRenamedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsRenamedEvent_Def.__bases__: + bases = list(ns0.DvsRenamedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsRenamedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsReconfiguredEvent_Def.schema + TClist = [GTD("urn:vim25","DVSConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsReconfiguredEvent_Def.__bases__: + bases = list(ns0.DvsReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsUpgradeAvailableEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsUpgradeAvailableEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsUpgradeAvailableEvent_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsUpgradeAvailableEvent_Def.__bases__: + bases = list(ns0.DvsUpgradeAvailableEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsUpgradeAvailableEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsUpgradeInProgressEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsUpgradeInProgressEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsUpgradeInProgressEvent_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsUpgradeInProgressEvent_Def.__bases__: + bases = list(ns0.DvsUpgradeInProgressEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsUpgradeInProgressEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsUpgradeRejectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsUpgradeRejectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsUpgradeRejectedEvent_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsUpgradeRejectedEvent_Def.__bases__: + bases = list(ns0.DvsUpgradeRejectedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsUpgradeRejectedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsUpgradedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsUpgradedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsUpgradedEvent_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsUpgradedEvent_Def.__bases__: + bases = list(ns0.DvsUpgradedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsUpgradedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsHostJoinedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsHostJoinedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsHostJoinedEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"hostJoined"), aname="_hostJoined", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsHostJoinedEvent_Def.__bases__: + bases = list(ns0.DvsHostJoinedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsHostJoinedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsHostLeftEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsHostLeftEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsHostLeftEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"hostLeft"), aname="_hostLeft", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsHostLeftEvent_Def.__bases__: + bases = list(ns0.DvsHostLeftEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsHostLeftEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsOutOfSyncHostArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsOutOfSyncHostArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsOutOfSyncHostArgument_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"outOfSyncHost"), aname="_outOfSyncHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configParamters"), aname="_configParamters", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DvsOutOfSyncHostArgument_Def.__bases__: + bases = list(ns0.DvsOutOfSyncHostArgument_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DvsOutOfSyncHostArgument_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDvsOutOfSyncHostArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDvsOutOfSyncHostArgument") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDvsOutOfSyncHostArgument_Def.schema + TClist = [GTD("urn:vim25","DvsOutOfSyncHostArgument",lazy=True)(pname=(ns,"DvsOutOfSyncHostArgument"), aname="_DvsOutOfSyncHostArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DvsOutOfSyncHostArgument = [] + return + Holder.__name__ = "ArrayOfDvsOutOfSyncHostArgument_Holder" + self.pyclass = Holder + + class OutOfSyncDvsHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OutOfSyncDvsHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OutOfSyncDvsHost_Def.schema + TClist = [GTD("urn:vim25","DvsOutOfSyncHostArgument",lazy=True)(pname=(ns,"hostOutOfSync"), aname="_hostOutOfSync", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.OutOfSyncDvsHost_Def.__bases__: + bases = list(ns0.OutOfSyncDvsHost_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.OutOfSyncDvsHost_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsHostWentOutOfSyncEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsHostWentOutOfSyncEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsHostWentOutOfSyncEvent_Def.schema + TClist = [GTD("urn:vim25","DvsOutOfSyncHostArgument",lazy=True)(pname=(ns,"hostOutOfSync"), aname="_hostOutOfSync", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsHostWentOutOfSyncEvent_Def.__bases__: + bases = list(ns0.DvsHostWentOutOfSyncEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsHostWentOutOfSyncEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsHostBackInSyncEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsHostBackInSyncEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsHostBackInSyncEvent_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"hostBackInSync"), aname="_hostBackInSync", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsHostBackInSyncEvent_Def.__bases__: + bases = list(ns0.DvsHostBackInSyncEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsHostBackInSyncEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortCreatedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortCreatedEvent_Def.__bases__: + bases = list(ns0.DvsPortCreatedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortReconfiguredEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortReconfiguredEvent_Def.__bases__: + bases = list(ns0.DvsPortReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortDeletedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortDeletedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortDeletedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortDeletedEvent_Def.__bases__: + bases = list(ns0.DvsPortDeletedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortDeletedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortConnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortConnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortConnectedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnectee",lazy=True)(pname=(ns,"connectee"), aname="_connectee", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortConnectedEvent_Def.__bases__: + bases = list(ns0.DvsPortConnectedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortConnectedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortDisconnectedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortDisconnectedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortDisconnectedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnectee",lazy=True)(pname=(ns,"connectee"), aname="_connectee", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortDisconnectedEvent_Def.__bases__: + bases = list(ns0.DvsPortDisconnectedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortDisconnectedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortLinkUpEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortLinkUpEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortLinkUpEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortLinkUpEvent_Def.__bases__: + bases = list(ns0.DvsPortLinkUpEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortLinkUpEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortLinkDownEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortLinkDownEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortLinkDownEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortLinkDownEvent_Def.__bases__: + bases = list(ns0.DvsPortLinkDownEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortLinkDownEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortJoinPortgroupEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortJoinPortgroupEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortJoinPortgroupEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortJoinPortgroupEvent_Def.__bases__: + bases = list(ns0.DvsPortJoinPortgroupEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortJoinPortgroupEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortLeavePortgroupEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortLeavePortgroupEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortLeavePortgroupEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortLeavePortgroupEvent_Def.__bases__: + bases = list(ns0.DvsPortLeavePortgroupEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortLeavePortgroupEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortBlockedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortBlockedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortBlockedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortBlockedEvent_Def.__bases__: + bases = list(ns0.DvsPortBlockedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortBlockedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsPortUnblockedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsPortUnblockedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsPortUnblockedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsPortUnblockedEvent_Def.__bases__: + bases = list(ns0.DvsPortUnblockedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsPortUnblockedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsDestroyedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsDestroyedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsDestroyedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsDestroyedEvent_Def.__bases__: + bases = list(ns0.DvsDestroyedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsDestroyedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsMergedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsMergedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsMergedEvent_Def.schema + TClist = [GTD("urn:vim25","DvsEventArgument",lazy=True)(pname=(ns,"sourceDvs"), aname="_sourceDvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsEventArgument",lazy=True)(pname=(ns,"destinationDvs"), aname="_destinationDvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsEvent_Def not in ns0.DvsMergedEvent_Def.__bases__: + bases = list(ns0.DvsMergedEvent_Def.__bases__) + bases.insert(0, ns0.DvsEvent_Def) + ns0.DvsMergedEvent_Def.__bases__ = tuple(bases) + + ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortgroupEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Event_Def not in ns0.DVPortgroupEvent_Def.__bases__: + bases = list(ns0.DVPortgroupEvent_Def.__bases__) + bases.insert(0, ns0.Event_Def) + ns0.DVPortgroupEvent_Def.__bases__ = tuple(bases) + + ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortgroupCreatedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupCreatedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupCreatedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupCreatedEvent_Def.__bases__: + bases = list(ns0.DVPortgroupCreatedEvent_Def.__bases__) + bases.insert(0, ns0.DVPortgroupEvent_Def) + ns0.DVPortgroupCreatedEvent_Def.__bases__ = tuple(bases) + + ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortgroupRenamedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupRenamedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupRenamedEvent_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupRenamedEvent_Def.__bases__: + bases = list(ns0.DVPortgroupRenamedEvent_Def.__bases__) + bases.insert(0, ns0.DVPortgroupEvent_Def) + ns0.DVPortgroupRenamedEvent_Def.__bases__ = tuple(bases) + + ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortgroupReconfiguredEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupReconfiguredEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupReconfiguredEvent_Def.schema + TClist = [GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupReconfiguredEvent_Def.__bases__: + bases = list(ns0.DVPortgroupReconfiguredEvent_Def.__bases__) + bases.insert(0, ns0.DVPortgroupEvent_Def) + ns0.DVPortgroupReconfiguredEvent_Def.__bases__ = tuple(bases) + + ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DVPortgroupDestroyedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DVPortgroupDestroyedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DVPortgroupDestroyedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupDestroyedEvent_Def.__bases__: + bases = list(ns0.DVPortgroupDestroyedEvent_Def.__bases__) + bases.insert(0, ns0.DVPortgroupEvent_Def) + ns0.DVPortgroupDestroyedEvent_Def.__bases__ = tuple(bases) + + ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsInvocationFailedEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsInvocationFailedEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsInvocationFailedEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DrsInvocationFailedEvent_Def.__bases__: + bases = list(ns0.DrsInvocationFailedEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DrsInvocationFailedEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsRecoveredFromFailureEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsRecoveredFromFailureEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsRecoveredFromFailureEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterEvent_Def not in ns0.DrsRecoveredFromFailureEvent_Def.__bases__: + bases = list(ns0.DrsRecoveredFromFailureEvent_Def.__bases__) + bases.insert(0, ns0.ClusterEvent_Def) + ns0.DrsRecoveredFromFailureEvent_Def.__bases__ = tuple(bases) + + ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventArgument_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventArgument_Def.__bases__: + bases = list(ns0.EventArgument_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventArgument_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RoleEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RoleEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RoleEventArgument_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EventArgument_Def not in ns0.RoleEventArgument_Def.__bases__: + bases = list(ns0.RoleEventArgument_Def.__bases__) + bases.insert(0, ns0.EventArgument_Def) + ns0.RoleEventArgument_Def.__bases__ = tuple(bases) + + ns0.EventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EntityEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EntityEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EntityEventArgument_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EventArgument_Def not in ns0.EntityEventArgument_Def.__bases__: + bases = list(ns0.EntityEventArgument_Def.__bases__) + bases.insert(0, ns0.EventArgument_Def) + ns0.EntityEventArgument_Def.__bases__ = tuple(bases) + + ns0.EventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ManagedEntityEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ManagedEntityEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ManagedEntityEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.ManagedEntityEventArgument_Def.__bases__: + bases = list(ns0.ManagedEntityEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.ManagedEntityEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FolderEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FolderEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FolderEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"folder"), aname="_folder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.FolderEventArgument_Def.__bases__: + bases = list(ns0.FolderEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.FolderEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatacenterEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatacenterEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatacenterEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.DatacenterEventArgument_Def.__bases__: + bases = list(ns0.DatacenterEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.DatacenterEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ComputeResourceEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComputeResourceEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComputeResourceEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"computeResource"), aname="_computeResource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.ComputeResourceEventArgument_Def.__bases__: + bases = list(ns0.ComputeResourceEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.ComputeResourceEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourcePoolEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourcePoolEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourcePoolEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.ResourcePoolEventArgument_Def.__bases__: + bases = list(ns0.ResourcePoolEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.ResourcePoolEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.HostEventArgument_Def.__bases__: + bases = list(ns0.HostEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.HostEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostEventArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostEventArgument") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostEventArgument_Def.schema + TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"HostEventArgument"), aname="_HostEventArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostEventArgument = [] + return + Holder.__name__ = "ArrayOfHostEventArgument_Holder" + self.pyclass = Holder + + class VmEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.VmEventArgument_Def.__bases__: + bases = list(ns0.VmEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.VmEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVmEventArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVmEventArgument") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVmEventArgument_Def.schema + TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"VmEventArgument"), aname="_VmEventArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VmEventArgument = [] + return + Holder.__name__ = "ArrayOfVmEventArgument_Holder" + self.pyclass = Holder + + class DatastoreEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.DatastoreEventArgument_Def.__bases__: + bases = list(ns0.DatastoreEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.DatastoreEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NetworkEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworkEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworkEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.NetworkEventArgument_Def.__bases__: + bases = list(ns0.NetworkEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.NetworkEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlarmEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlarmEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlarmEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.AlarmEventArgument_Def.__bases__: + bases = list(ns0.AlarmEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.AlarmEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.ScheduledTaskEventArgument_Def.__bases__: + bases = list(ns0.ScheduledTaskEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.ScheduledTaskEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EventArgument_Def not in ns0.ProfileEventArgument_Def.__bases__: + bases = list(ns0.ProfileEventArgument_Def.__bases__) + bases.insert(0, ns0.EventArgument_Def) + ns0.ProfileEventArgument_Def.__bases__ = tuple(bases) + + ns0.EventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsEventArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsEventArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsEventArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EntityEventArgument_Def not in ns0.DvsEventArgument_Def.__bases__: + bases = list(ns0.DvsEventArgument_Def.__bases__) + bases.insert(0, ns0.EntityEventArgument_Def) + ns0.DvsEventArgument_Def.__bases__ = tuple(bases) + + ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EventCategory_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EventCategory") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class EventArgDesc_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventArgDesc") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventArgDesc_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventArgDesc_Def.__bases__: + bases = list(ns0.EventArgDesc_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventArgDesc_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfEventArgDesc_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfEventArgDesc") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfEventArgDesc_Def.schema + TClist = [GTD("urn:vim25","EventArgDesc",lazy=True)(pname=(ns,"EventArgDesc"), aname="_EventArgDesc", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._EventArgDesc = [] + return + Holder.__name__ = "ArrayOfEventArgDesc_Holder" + self.pyclass = Holder + + class EventDescriptionEventDetail_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventDescriptionEventDetail") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventDescriptionEventDetail_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnDatacenter"), aname="_formatOnDatacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnComputeResource"), aname="_formatOnComputeResource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnHost"), aname="_formatOnHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnVm"), aname="_formatOnVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullFormat"), aname="_fullFormat", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventDescriptionEventDetail_Def.__bases__: + bases = list(ns0.EventDescriptionEventDetail_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventDescriptionEventDetail_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfEventDescriptionEventDetail_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfEventDescriptionEventDetail") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfEventDescriptionEventDetail_Def.schema + TClist = [GTD("urn:vim25","EventDescriptionEventDetail",lazy=True)(pname=(ns,"EventDescriptionEventDetail"), aname="_EventDescriptionEventDetail", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._EventDescriptionEventDetail = [] + return + Holder.__name__ = "ArrayOfEventDescriptionEventDetail_Holder" + self.pyclass = Holder + + class EventDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventDescription_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"category"), aname="_category", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventDescriptionEventDetail",lazy=True)(pname=(ns,"eventInfo"), aname="_eventInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EnumDescription",lazy=True)(pname=(ns,"enumeratedTypes"), aname="_enumeratedTypes", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventDescription_Def.__bases__: + bases = list(ns0.EventDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EventFilterSpecRecursionOption_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EventFilterSpecRecursionOption") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class EventFilterSpecByEntity_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventFilterSpecByEntity") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventFilterSpecByEntity_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpecRecursionOption",lazy=True)(pname=(ns,"recursion"), aname="_recursion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventFilterSpecByEntity_Def.__bases__: + bases = list(ns0.EventFilterSpecByEntity_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventFilterSpecByEntity_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EventFilterSpecByTime_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventFilterSpecByTime") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventFilterSpecByTime_Def.schema + TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"beginTime"), aname="_beginTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventFilterSpecByTime_Def.__bases__: + bases = list(ns0.EventFilterSpecByTime_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventFilterSpecByTime_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EventFilterSpecByUsername_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventFilterSpecByUsername") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventFilterSpecByUsername_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"systemUser"), aname="_systemUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userList"), aname="_userList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventFilterSpecByUsername_Def.__bases__: + bases = list(ns0.EventFilterSpecByUsername_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventFilterSpecByUsername_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EventFilterSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EventFilterSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EventFilterSpec_Def.schema + TClist = [GTD("urn:vim25","EventFilterSpecByEntity",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpecByTime",lazy=True)(pname=(ns,"time"), aname="_time", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpecByUsername",lazy=True)(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"eventChainId"), aname="_eventChainId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"disableFullMessage"), aname="_disableFullMessage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"tag"), aname="_tag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.EventFilterSpec_Def.__bases__: + bases = list(ns0.EventFilterSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.EventFilterSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReadNextEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReadNextEventsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReadNextEventsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._maxCount = None + return + Holder.__name__ = "ReadNextEventsRequestType_Holder" + self.pyclass = Holder + + class ReadPreviousEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReadPreviousEventsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReadPreviousEventsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._maxCount = None + return + Holder.__name__ = "ReadPreviousEventsRequestType_Holder" + self.pyclass = Holder + + class RetrieveArgumentDescriptionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveArgumentDescriptionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveArgumentDescriptionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._eventTypeId = None + return + Holder.__name__ = "RetrieveArgumentDescriptionRequestType_Holder" + self.pyclass = Holder + + class CreateCollectorForEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateCollectorForEventsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateCollectorForEventsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpec",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._filter = None + return + Holder.__name__ = "CreateCollectorForEventsRequestType_Holder" + self.pyclass = Holder + + class LogUserEventRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LogUserEventRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.LogUserEventRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"msg"), aname="_msg", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._msg = None + return + Holder.__name__ = "LogUserEventRequestType_Holder" + self.pyclass = Holder + + class QueryEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryEventsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryEventsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpec",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._filter = None + return + Holder.__name__ = "QueryEventsRequestType_Holder" + self.pyclass = Holder + + class PostEventRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PostEventRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.PostEventRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Event",lazy=True)(pname=(ns,"eventToPost"), aname="_eventToPost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"taskInfo"), aname="_taskInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._eventToPost = None + self._taskInfo = None + return + Holder.__name__ = "PostEventRequestType_Holder" + self.pyclass = Holder + + class AdminDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AdminDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AdminDisabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.AdminDisabled_Def.__bases__: + bases = list(ns0.AdminDisabled_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.AdminDisabled_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AdminNotDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AdminNotDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AdminNotDisabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.AdminNotDisabled_Def.__bases__: + bases = list(ns0.AdminNotDisabled_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.AdminNotDisabled_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AffinityType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AffinityType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class AffinityConfigured_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AffinityConfigured") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AffinityConfigured_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"configuredAffinity"), aname="_configuredAffinity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.AffinityConfigured_Def.__bases__: + bases = list(ns0.AffinityConfigured_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.AffinityConfigured_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AgentInstallFailedReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AgentInstallFailedReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class AgentInstallFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AgentInstallFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AgentInstallFailed_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"statusCode"), aname="_statusCode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installerOutput"), aname="_installerOutput", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.AgentInstallFailed_Def.__bases__: + bases = list(ns0.AgentInstallFailed_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.AgentInstallFailed_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlreadyBeingManaged_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlreadyBeingManaged") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlreadyBeingManaged_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.AlreadyBeingManaged_Def.__bases__: + bases = list(ns0.AlreadyBeingManaged_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.AlreadyBeingManaged_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlreadyConnected_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlreadyConnected") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlreadyConnected_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.AlreadyConnected_Def.__bases__: + bases = list(ns0.AlreadyConnected_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.AlreadyConnected_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlreadyExists_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlreadyExists") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlreadyExists_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.AlreadyExists_Def.__bases__: + bases = list(ns0.AlreadyExists_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.AlreadyExists_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AlreadyUpgraded_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AlreadyUpgraded") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AlreadyUpgraded_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.AlreadyUpgraded_Def.__bases__: + bases = list(ns0.AlreadyUpgraded_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.AlreadyUpgraded_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ApplicationQuiesceFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ApplicationQuiesceFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ApplicationQuiesceFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.ApplicationQuiesceFault_Def.__bases__: + bases = list(ns0.ApplicationQuiesceFault_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.ApplicationQuiesceFault_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AuthMinimumAdminPermission_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AuthMinimumAdminPermission") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AuthMinimumAdminPermission_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.AuthMinimumAdminPermission_Def.__bases__: + bases = list(ns0.AuthMinimumAdminPermission_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.AuthMinimumAdminPermission_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAccessFile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAccessFile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAccessFile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.CannotAccessFile_Def.__bases__: + bases = list(ns0.CannotAccessFile_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.CannotAccessFile_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAccessLocalSource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAccessLocalSource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAccessLocalSource_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.CannotAccessLocalSource_Def.__bases__: + bases = list(ns0.CannotAccessLocalSource_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.CannotAccessLocalSource_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAccessNetwork_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAccessNetwork") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAccessNetwork_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessVmDevice_Def not in ns0.CannotAccessNetwork_Def.__bases__: + bases = list(ns0.CannotAccessNetwork_Def.__bases__) + bases.insert(0, ns0.CannotAccessVmDevice_Def) + ns0.CannotAccessNetwork_Def.__bases__ = tuple(bases) + + ns0.CannotAccessVmDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAccessVmComponent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAccessVmComponent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAccessVmComponent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.CannotAccessVmComponent_Def.__bases__: + bases = list(ns0.CannotAccessVmComponent_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.CannotAccessVmComponent_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAccessVmConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAccessVmConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAccessVmConfig_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessVmComponent_Def not in ns0.CannotAccessVmConfig_Def.__bases__: + bases = list(ns0.CannotAccessVmConfig_Def.__bases__) + bases.insert(0, ns0.CannotAccessVmComponent_Def) + ns0.CannotAccessVmConfig_Def.__bases__ = tuple(bases) + + ns0.CannotAccessVmComponent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAccessVmDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAccessVmDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAccessVmDevice_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessVmComponent_Def not in ns0.CannotAccessVmDevice_Def.__bases__: + bases = list(ns0.CannotAccessVmDevice_Def.__bases__) + bases.insert(0, ns0.CannotAccessVmComponent_Def) + ns0.CannotAccessVmDevice_Def.__bases__ = tuple(bases) + + ns0.CannotAccessVmComponent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAccessVmDisk_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAccessVmDisk") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAccessVmDisk_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessVmDevice_Def not in ns0.CannotAccessVmDisk_Def.__bases__: + bases = list(ns0.CannotAccessVmDisk_Def.__bases__) + bases.insert(0, ns0.CannotAccessVmDevice_Def) + ns0.CannotAccessVmDisk_Def.__bases__ = tuple(bases) + + ns0.CannotAccessVmDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAddHostWithFTVmAsStandalone_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAddHostWithFTVmAsStandalone") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAddHostWithFTVmAsStandalone_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.CannotAddHostWithFTVmAsStandalone_Def.__bases__: + bases = list(ns0.CannotAddHostWithFTVmAsStandalone_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.CannotAddHostWithFTVmAsStandalone_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAddHostWithFTVmToDifferentCluster_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAddHostWithFTVmToDifferentCluster") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAddHostWithFTVmToDifferentCluster_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__bases__: + bases = list(ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotAddHostWithFTVmToNonHACluster_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotAddHostWithFTVmToNonHACluster") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotAddHostWithFTVmToNonHACluster_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.CannotAddHostWithFTVmToNonHACluster_Def.__bases__: + bases = list(ns0.CannotAddHostWithFTVmToNonHACluster_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.CannotAddHostWithFTVmToNonHACluster_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotCreateFile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotCreateFile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotCreateFile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.CannotCreateFile_Def.__bases__: + bases = list(ns0.CannotCreateFile_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.CannotCreateFile_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotDecryptPasswords_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotDecryptPasswords") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotDecryptPasswords_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.CannotDecryptPasswords_Def.__bases__: + bases = list(ns0.CannotDecryptPasswords_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.CannotDecryptPasswords_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotDeleteFile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotDeleteFile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotDeleteFile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.CannotDeleteFile_Def.__bases__: + bases = list(ns0.CannotDeleteFile_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.CannotDeleteFile_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotDisableSnapshot_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotDisableSnapshot") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotDisableSnapshot_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.CannotDisableSnapshot_Def.__bases__: + bases = list(ns0.CannotDisableSnapshot_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.CannotDisableSnapshot_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotDisconnectHostWithFaultToleranceVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotDisconnectHostWithFaultToleranceVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotDisconnectHostWithFaultToleranceVm_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__bases__: + bases = list(ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotModifyConfigCpuRequirements_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotModifyConfigCpuRequirements") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotModifyConfigCpuRequirements_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.CannotModifyConfigCpuRequirements_Def.__bases__: + bases = list(ns0.CannotModifyConfigCpuRequirements_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.CannotModifyConfigCpuRequirements_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotMoveFaultToleranceVmMoveType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CannotMoveFaultToleranceVmMoveType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class CannotMoveFaultToleranceVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotMoveFaultToleranceVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotMoveFaultToleranceVm_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"moveType"), aname="_moveType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.CannotMoveFaultToleranceVm_Def.__bases__: + bases = list(ns0.CannotMoveFaultToleranceVm_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.CannotMoveFaultToleranceVm_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CannotMoveHostWithFaultToleranceVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CannotMoveHostWithFaultToleranceVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CannotMoveHostWithFaultToleranceVm_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.CannotMoveHostWithFaultToleranceVm_Def.__bases__: + bases = list(ns0.CannotMoveHostWithFaultToleranceVm_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.CannotMoveHostWithFaultToleranceVm_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CloneFromSnapshotNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CloneFromSnapshotNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CloneFromSnapshotNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.CloneFromSnapshotNotSupported_Def.__bases__: + bases = list(ns0.CloneFromSnapshotNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.CloneFromSnapshotNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ConcurrentAccess_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ConcurrentAccess") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ConcurrentAccess_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.ConcurrentAccess_Def.__bases__: + bases = list(ns0.ConcurrentAccess_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.ConcurrentAccess_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ConnectedIso_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ConnectedIso") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ConnectedIso_Def.schema + TClist = [GTD("urn:vim25","VirtualCdrom",lazy=True)(pname=(ns,"cdrom"), aname="_cdrom", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfExport_Def not in ns0.ConnectedIso_Def.__bases__: + bases = list(ns0.ConnectedIso_Def.__bases__) + bases.insert(0, ns0.OvfExport_Def) + ns0.ConnectedIso_Def.__bases__ = tuple(bases) + + ns0.OvfExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CpuCompatibilityUnknown_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CpuCompatibilityUnknown") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CpuCompatibilityUnknown_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CpuIncompatible_Def not in ns0.CpuCompatibilityUnknown_Def.__bases__: + bases = list(ns0.CpuCompatibilityUnknown_Def.__bases__) + bases.insert(0, ns0.CpuIncompatible_Def) + ns0.CpuCompatibilityUnknown_Def.__bases__ = tuple(bases) + + ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CpuHotPlugNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CpuHotPlugNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CpuHotPlugNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.CpuHotPlugNotSupported_Def.__bases__: + bases = list(ns0.CpuHotPlugNotSupported_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.CpuHotPlugNotSupported_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CpuIncompatible_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CpuIncompatible") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CpuIncompatible_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"registerName"), aname="_registerName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"registerBits"), aname="_registerBits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"desiredBits"), aname="_desiredBits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.CpuIncompatible_Def.__bases__: + bases = list(ns0.CpuIncompatible_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.CpuIncompatible_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CpuIncompatible1ECX_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CpuIncompatible1ECX") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CpuIncompatible1ECX_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"sse3"), aname="_sse3", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ssse3"), aname="_ssse3", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sse41"), aname="_sse41", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sse42"), aname="_sse42", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"other"), aname="_other", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"otherOnly"), aname="_otherOnly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CpuIncompatible_Def not in ns0.CpuIncompatible1ECX_Def.__bases__: + bases = list(ns0.CpuIncompatible1ECX_Def.__bases__) + bases.insert(0, ns0.CpuIncompatible_Def) + ns0.CpuIncompatible1ECX_Def.__bases__ = tuple(bases) + + ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CpuIncompatible81EDX_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CpuIncompatible81EDX") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CpuIncompatible81EDX_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"nx"), aname="_nx", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ffxsr"), aname="_ffxsr", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rdtscp"), aname="_rdtscp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"lm"), aname="_lm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"other"), aname="_other", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"otherOnly"), aname="_otherOnly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CpuIncompatible_Def not in ns0.CpuIncompatible81EDX_Def.__bases__: + bases = list(ns0.CpuIncompatible81EDX_Def.__bases__) + bases.insert(0, ns0.CpuIncompatible_Def) + ns0.CpuIncompatible81EDX_Def.__bases__ = tuple(bases) + + ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.CustomizationFault_Def.__bases__: + bases = list(ns0.CustomizationFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.CustomizationFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationPending_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationPending") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationPending_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.CustomizationPending_Def.__bases__: + bases = list(ns0.CustomizationPending_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.CustomizationPending_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DasConfigFaultDasConfigFaultReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DasConfigFaultDasConfigFaultReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DasConfigFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DasConfigFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DasConfigFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"output"), aname="_output", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Event",lazy=True)(pname=(ns,"event"), aname="_event", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.DasConfigFault_Def.__bases__: + bases = list(ns0.DasConfigFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.DasConfigFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatabaseError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatabaseError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatabaseError_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.DatabaseError_Def.__bases__: + bases = list(ns0.DatabaseError_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.DatabaseError_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatacenterMismatchArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatacenterMismatchArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatacenterMismatchArgument_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"inputDatacenter"), aname="_inputDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatacenterMismatchArgument_Def.__bases__: + bases = list(ns0.DatacenterMismatchArgument_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatacenterMismatchArgument_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDatacenterMismatchArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDatacenterMismatchArgument") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDatacenterMismatchArgument_Def.schema + TClist = [GTD("urn:vim25","DatacenterMismatchArgument",lazy=True)(pname=(ns,"DatacenterMismatchArgument"), aname="_DatacenterMismatchArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DatacenterMismatchArgument = [] + return + Holder.__name__ = "ArrayOfDatacenterMismatchArgument_Holder" + self.pyclass = Holder + + class DatacenterMismatch_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatacenterMismatch") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatacenterMismatch_Def.schema + TClist = [GTD("urn:vim25","DatacenterMismatchArgument",lazy=True)(pname=(ns,"invalidArgument"), aname="_invalidArgument", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"expectedDatacenter"), aname="_expectedDatacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.DatacenterMismatch_Def.__bases__: + bases = list(ns0.DatacenterMismatch_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.DatacenterMismatch_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DatastoreNotWritableOnHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreNotWritableOnHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreNotWritableOnHost_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDatastore_Def not in ns0.DatastoreNotWritableOnHost_Def.__bases__: + bases = list(ns0.DatastoreNotWritableOnHost_Def.__bases__) + bases.insert(0, ns0.InvalidDatastore_Def) + ns0.DatastoreNotWritableOnHost_Def.__bases__ = tuple(bases) + + ns0.InvalidDatastore_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DestinationSwitchFull_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DestinationSwitchFull") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DestinationSwitchFull_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessNetwork_Def not in ns0.DestinationSwitchFull_Def.__bases__: + bases = list(ns0.DestinationSwitchFull_Def.__bases__) + bases.insert(0, ns0.CannotAccessNetwork_Def) + ns0.DestinationSwitchFull_Def.__bases__ = tuple(bases) + + ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceBackingNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceBackingNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceBackingNotSupported_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.DeviceBackingNotSupported_Def.__bases__: + bases = list(ns0.DeviceBackingNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.DeviceBackingNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceControllerNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceControllerNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceControllerNotSupported_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"controller"), aname="_controller", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.DeviceControllerNotSupported_Def.__bases__: + bases = list(ns0.DeviceControllerNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.DeviceControllerNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceHotPlugNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceHotPlugNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceHotPlugNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.DeviceHotPlugNotSupported_Def.__bases__: + bases = list(ns0.DeviceHotPlugNotSupported_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.DeviceHotPlugNotSupported_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceNotFound_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.DeviceNotFound_Def.__bases__: + bases = list(ns0.DeviceNotFound_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.DeviceNotFound_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceNotSupportedReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DeviceNotSupportedReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DeviceNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceNotSupported_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.DeviceNotSupported_Def.__bases__: + bases = list(ns0.DeviceNotSupported_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.DeviceNotSupported_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceUnsupportedForVmPlatform_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceUnsupportedForVmPlatform") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceUnsupportedForVmPlatform_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.DeviceUnsupportedForVmPlatform_Def.__bases__: + bases = list(ns0.DeviceUnsupportedForVmPlatform_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.DeviceUnsupportedForVmPlatform_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DeviceUnsupportedForVmVersion_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DeviceUnsupportedForVmVersion") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DeviceUnsupportedForVmVersion_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"currentVersion"), aname="_currentVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expectedVersion"), aname="_expectedVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.DeviceUnsupportedForVmVersion_Def.__bases__: + bases = list(ns0.DeviceUnsupportedForVmVersion_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.DeviceUnsupportedForVmVersion_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DisableAdminNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DisableAdminNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DisableAdminNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.DisableAdminNotSupported_Def.__bases__: + bases = list(ns0.DisableAdminNotSupported_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.DisableAdminNotSupported_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DisallowedDiskModeChange_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DisallowedDiskModeChange") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DisallowedDiskModeChange_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.DisallowedDiskModeChange_Def.__bases__: + bases = list(ns0.DisallowedDiskModeChange_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.DisallowedDiskModeChange_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DisallowedMigrationDeviceAttached_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DisallowedMigrationDeviceAttached") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DisallowedMigrationDeviceAttached_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.DisallowedMigrationDeviceAttached_Def.__bases__: + bases = list(ns0.DisallowedMigrationDeviceAttached_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.DisallowedMigrationDeviceAttached_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DisallowedOperationOnFailoverHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DisallowedOperationOnFailoverHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DisallowedOperationOnFailoverHost_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.DisallowedOperationOnFailoverHost_Def.__bases__: + bases = list(ns0.DisallowedOperationOnFailoverHost_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.DisallowedOperationOnFailoverHost_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DiskMoveTypeNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DiskMoveTypeNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DiskMoveTypeNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.DiskMoveTypeNotSupported_Def.__bases__: + bases = list(ns0.DiskMoveTypeNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.DiskMoveTypeNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DiskNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DiskNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DiskNotSupported_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"disk"), aname="_disk", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.DiskNotSupported_Def.__bases__: + bases = list(ns0.DiskNotSupported_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.DiskNotSupported_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsDisabledOnVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsDisabledOnVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsDisabledOnVm_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.DrsDisabledOnVm_Def.__bases__: + bases = list(ns0.DrsDisabledOnVm_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.DrsDisabledOnVm_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DrsVmotionIncompatibleFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DrsVmotionIncompatibleFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DrsVmotionIncompatibleFault_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.DrsVmotionIncompatibleFault_Def.__bases__: + bases = list(ns0.DrsVmotionIncompatibleFault_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.DrsVmotionIncompatibleFault_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DuplicateName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DuplicateName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DuplicateName_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"object"), aname="_object", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.DuplicateName_Def.__bases__: + bases = list(ns0.DuplicateName_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.DuplicateName_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.DvsFault_Def.__bases__: + bases = list(ns0.DvsFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.DvsFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsNotAuthorized_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsNotAuthorized") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsNotAuthorized_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"sessionExtensionKey"), aname="_sessionExtensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dvsExtensionKey"), aname="_dvsExtensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsFault_Def not in ns0.DvsNotAuthorized_Def.__bases__: + bases = list(ns0.DvsNotAuthorized_Def.__bases__) + bases.insert(0, ns0.DvsFault_Def) + ns0.DvsNotAuthorized_Def.__bases__ = tuple(bases) + + ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsOperationBulkFaultFaultOnHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsOperationBulkFaultFaultOnHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsOperationBulkFaultFaultOnHost_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DvsOperationBulkFaultFaultOnHost_Def.__bases__: + bases = list(ns0.DvsOperationBulkFaultFaultOnHost_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DvsOperationBulkFaultFaultOnHost_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDvsOperationBulkFaultFaultOnHost_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDvsOperationBulkFaultFaultOnHost") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDvsOperationBulkFaultFaultOnHost_Def.schema + TClist = [GTD("urn:vim25","DvsOperationBulkFaultFaultOnHost",lazy=True)(pname=(ns,"DvsOperationBulkFaultFaultOnHost"), aname="_DvsOperationBulkFaultFaultOnHost", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DvsOperationBulkFaultFaultOnHost = [] + return + Holder.__name__ = "ArrayOfDvsOperationBulkFaultFaultOnHost_Holder" + self.pyclass = Holder + + class DvsOperationBulkFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsOperationBulkFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsOperationBulkFault_Def.schema + TClist = [GTD("urn:vim25","DvsOperationBulkFaultFaultOnHost",lazy=True)(pname=(ns,"hostFault"), aname="_hostFault", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsFault_Def not in ns0.DvsOperationBulkFault_Def.__bases__: + bases = list(ns0.DvsOperationBulkFault_Def.__bases__) + bases.insert(0, ns0.DvsFault_Def) + ns0.DvsOperationBulkFault_Def.__bases__ = tuple(bases) + + ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsScopeViolated_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsScopeViolated") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsScopeViolated_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsFault_Def not in ns0.DvsScopeViolated_Def.__bases__: + bases = list(ns0.DvsScopeViolated_Def.__bases__) + bases.insert(0, ns0.DvsFault_Def) + ns0.DvsScopeViolated_Def.__bases__ = tuple(bases) + + ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotSupportedHostInCluster_Def not in ns0.EVCAdmissionFailed_Def.__bases__: + bases = list(ns0.EVCAdmissionFailed_Def.__bases__) + bases.insert(0, ns0.NotSupportedHostInCluster_Def) + ns0.EVCAdmissionFailed_Def.__bases__ = tuple(bases) + + ns0.NotSupportedHostInCluster_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedCPUFeaturesForMode_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedCPUFeaturesForMode") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedCPUModel_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedCPUModel") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedCPUModel_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUModel_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUModel_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedCPUModel_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedCPUModelForMode_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedCPUModelForMode") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedCPUModelForMode_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUModelForMode_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUModelForMode_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedCPUModelForMode_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedCPUVendor_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedCPUVendor") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedCPUVendor_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"clusterCPUVendor"), aname="_clusterCPUVendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostCPUVendor"), aname="_hostCPUVendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUVendor_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUVendor_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedCPUVendor_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedCPUVendorUnknown_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedCPUVendorUnknown") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedCPUVendorUnknown_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedHostDisconnected_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedHostDisconnected") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedHostDisconnected_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedHostDisconnected_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedHostDisconnected_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedHostDisconnected_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedHostSoftware_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedHostSoftware") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedHostSoftware_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedHostSoftware_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedHostSoftware_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedHostSoftware_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedHostSoftwareForMode_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedHostSoftwareForMode") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedHostSoftwareForMode_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EVCAdmissionFailedVmActive_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EVCAdmissionFailedVmActive") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EVCAdmissionFailedVmActive_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedVmActive_Def.__bases__: + bases = list(ns0.EVCAdmissionFailedVmActive_Def.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedVmActive_Def.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EightHostLimitViolated_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "EightHostLimitViolated") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.EightHostLimitViolated_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.EightHostLimitViolated_Def.__bases__: + bases = list(ns0.EightHostLimitViolated_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.EightHostLimitViolated_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExpiredAddonLicense_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExpiredAddonLicense") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExpiredAddonLicense_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ExpiredFeatureLicense_Def not in ns0.ExpiredAddonLicense_Def.__bases__: + bases = list(ns0.ExpiredAddonLicense_Def.__bases__) + bases.insert(0, ns0.ExpiredFeatureLicense_Def) + ns0.ExpiredAddonLicense_Def.__bases__ = tuple(bases) + + ns0.ExpiredFeatureLicense_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExpiredEditionLicense_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExpiredEditionLicense") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExpiredEditionLicense_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ExpiredFeatureLicense_Def not in ns0.ExpiredEditionLicense_Def.__bases__: + bases = list(ns0.ExpiredEditionLicense_Def.__bases__) + bases.insert(0, ns0.ExpiredFeatureLicense_Def) + ns0.ExpiredEditionLicense_Def.__bases__ = tuple(bases) + + ns0.ExpiredFeatureLicense_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExpiredFeatureLicense_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExpiredFeatureLicense") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExpiredFeatureLicense_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"count"), aname="_count", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"expirationDate"), aname="_expirationDate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.ExpiredFeatureLicense_Def.__bases__: + bases = list(ns0.ExpiredFeatureLicense_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.ExpiredFeatureLicense_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ExtendedFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ExtendedFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ExtendedFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"faultTypeId"), aname="_faultTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"data"), aname="_data", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.ExtendedFault_Def.__bases__: + bases = list(ns0.ExtendedFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.ExtendedFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultToleranceAntiAffinityViolated_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultToleranceAntiAffinityViolated") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultToleranceAntiAffinityViolated_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.FaultToleranceAntiAffinityViolated_Def.__bases__: + bases = list(ns0.FaultToleranceAntiAffinityViolated_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.FaultToleranceAntiAffinityViolated_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultToleranceCpuIncompatible_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultToleranceCpuIncompatible") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultToleranceCpuIncompatible_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"family"), aname="_family", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"stepping"), aname="_stepping", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CpuIncompatible_Def not in ns0.FaultToleranceCpuIncompatible_Def.__bases__: + bases = list(ns0.FaultToleranceCpuIncompatible_Def.__bases__) + bases.insert(0, ns0.CpuIncompatible_Def) + ns0.FaultToleranceCpuIncompatible_Def.__bases__ = tuple(bases) + + ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultToleranceNotLicensed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultToleranceNotLicensed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultToleranceNotLicensed_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.FaultToleranceNotLicensed_Def.__bases__: + bases = list(ns0.FaultToleranceNotLicensed_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.FaultToleranceNotLicensed_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultToleranceNotSameBuild_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultToleranceNotSameBuild") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultToleranceNotSameBuild_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"build"), aname="_build", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.FaultToleranceNotSameBuild_Def.__bases__: + bases = list(ns0.FaultToleranceNotSameBuild_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.FaultToleranceNotSameBuild_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultTolerancePrimaryPowerOnNotAttempted_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultTolerancePrimaryPowerOnNotAttempted") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"secondaryVm"), aname="_secondaryVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"primaryVm"), aname="_primaryVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__bases__: + bases = list(ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileAlreadyExists_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileAlreadyExists") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileAlreadyExists_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.FileAlreadyExists_Def.__bases__: + bases = list(ns0.FileAlreadyExists_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.FileAlreadyExists_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileBackedPortNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileBackedPortNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileBackedPortNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.FileBackedPortNotSupported_Def.__bases__: + bases = list(ns0.FileBackedPortNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.FileBackedPortNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"file"), aname="_file", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.FileFault_Def.__bases__: + bases = list(ns0.FileFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.FileFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileLocked_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileLocked") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileLocked_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.FileLocked_Def.__bases__: + bases = list(ns0.FileLocked_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.FileLocked_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileNotFound_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.FileNotFound_Def.__bases__: + bases = list(ns0.FileNotFound_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.FileNotFound_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileNotWritable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileNotWritable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileNotWritable_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.FileNotWritable_Def.__bases__: + bases = list(ns0.FileNotWritable_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.FileNotWritable_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileTooLarge_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileTooLarge") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileTooLarge_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"fileSize"), aname="_fileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxFileSize"), aname="_maxFileSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.FileTooLarge_Def.__bases__: + bases = list(ns0.FileTooLarge_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.FileTooLarge_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FilesystemQuiesceFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FilesystemQuiesceFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FilesystemQuiesceFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.FilesystemQuiesceFault_Def.__bases__: + bases = list(ns0.FilesystemQuiesceFault_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.FilesystemQuiesceFault_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FtIssuesOnHostHostSelectionType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FtIssuesOnHostHostSelectionType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class FtIssuesOnHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FtIssuesOnHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FtIssuesOnHost_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"errors"), aname="_errors", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.FtIssuesOnHost_Def.__bases__: + bases = list(ns0.FtIssuesOnHost_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.FtIssuesOnHost_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FullStorageVMotionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FullStorageVMotionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FullStorageVMotionNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFeatureNotSupported_Def not in ns0.FullStorageVMotionNotSupported_Def.__bases__: + bases = list(ns0.FullStorageVMotionNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFeatureNotSupported_Def) + ns0.FullStorageVMotionNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GenericDrsFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GenericDrsFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GenericDrsFault_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"hostFaults"), aname="_hostFaults", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.GenericDrsFault_Def.__bases__: + bases = list(ns0.GenericDrsFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.GenericDrsFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class GenericVmConfigFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GenericVmConfigFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GenericVmConfigFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.GenericVmConfigFault_Def.__bases__: + bases = list(ns0.GenericVmConfigFault_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.GenericVmConfigFault_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HAErrorsAtDest_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HAErrorsAtDest") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HAErrorsAtDest_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.HAErrorsAtDest_Def.__bases__: + bases = list(ns0.HAErrorsAtDest_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.HAErrorsAtDest_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigFailed_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"failure"), aname="_failure", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.HostConfigFailed_Def.__bases__: + bases = list(ns0.HostConfigFailed_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.HostConfigFailed_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.HostConfigFault_Def.__bases__: + bases = list(ns0.HostConfigFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.HostConfigFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConnectFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConnectFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConnectFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.HostConnectFault_Def.__bases__: + bases = list(ns0.HostConnectFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.HostConnectFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIncompatibleForFaultToleranceReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostIncompatibleForFaultToleranceReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostIncompatibleForFaultTolerance_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIncompatibleForFaultTolerance") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIncompatibleForFaultTolerance_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.HostIncompatibleForFaultTolerance_Def.__bases__: + bases = list(ns0.HostIncompatibleForFaultTolerance_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.HostIncompatibleForFaultTolerance_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIncompatibleForRecordReplayReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostIncompatibleForRecordReplayReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostIncompatibleForRecordReplay_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIncompatibleForRecordReplay") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIncompatibleForRecordReplay_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.HostIncompatibleForRecordReplay_Def.__bases__: + bases = list(ns0.HostIncompatibleForRecordReplay_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.HostIncompatibleForRecordReplay_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInventoryFull_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInventoryFull") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInventoryFull_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.HostInventoryFull_Def.__bases__: + bases = list(ns0.HostInventoryFull_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.HostInventoryFull_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostPowerOpFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPowerOpFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPowerOpFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.HostPowerOpFailed_Def.__bases__: + bases = list(ns0.HostPowerOpFailed_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.HostPowerOpFailed_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HotSnapshotMoveNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HotSnapshotMoveNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HotSnapshotMoveNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotCopyNotSupported_Def not in ns0.HotSnapshotMoveNotSupported_Def.__bases__: + bases = list(ns0.HotSnapshotMoveNotSupported_Def.__bases__) + bases.insert(0, ns0.SnapshotCopyNotSupported_Def) + ns0.HotSnapshotMoveNotSupported_Def.__bases__ = tuple(bases) + + ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IDEDiskNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IDEDiskNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IDEDiskNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DiskNotSupported_Def not in ns0.IDEDiskNotSupported_Def.__bases__: + bases = list(ns0.IDEDiskNotSupported_Def.__bases__) + bases.insert(0, ns0.DiskNotSupported_Def) + ns0.IDEDiskNotSupported_Def.__bases__ = tuple(bases) + + ns0.DiskNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InUseFeatureManipulationDisallowed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InUseFeatureManipulationDisallowed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InUseFeatureManipulationDisallowed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.InUseFeatureManipulationDisallowed_Def.__bases__: + bases = list(ns0.InUseFeatureManipulationDisallowed_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.InUseFeatureManipulationDisallowed_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InaccessibleDatastore_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InaccessibleDatastore") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InaccessibleDatastore_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDatastore_Def not in ns0.InaccessibleDatastore_Def.__bases__: + bases = list(ns0.InaccessibleDatastore_Def.__bases__) + bases.insert(0, ns0.InvalidDatastore_Def) + ns0.InaccessibleDatastore_Def.__bases__ = tuple(bases) + + ns0.InvalidDatastore_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IncompatibleDefaultDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IncompatibleDefaultDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IncompatibleDefaultDevice_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.IncompatibleDefaultDevice_Def.__bases__: + bases = list(ns0.IncompatibleDefaultDevice_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.IncompatibleDefaultDevice_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IncompatibleHostForFtSecondary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IncompatibleHostForFtSecondary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IncompatibleHostForFtSecondary_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.IncompatibleHostForFtSecondary_Def.__bases__: + bases = list(ns0.IncompatibleHostForFtSecondary_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.IncompatibleHostForFtSecondary_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IncompatibleSetting_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IncompatibleSetting") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IncompatibleSetting_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"conflictingProperty"), aname="_conflictingProperty", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidArgument_Def not in ns0.IncompatibleSetting_Def.__bases__: + bases = list(ns0.IncompatibleSetting_Def.__bases__) + bases.insert(0, ns0.InvalidArgument_Def) + ns0.IncompatibleSetting_Def.__bases__ = tuple(bases) + + ns0.InvalidArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IncorrectFileType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IncorrectFileType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IncorrectFileType_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.IncorrectFileType_Def.__bases__: + bases = list(ns0.IncorrectFileType_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.IncorrectFileType_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IncorrectHostInformation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IncorrectHostInformation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IncorrectHostInformation_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.IncorrectHostInformation_Def.__bases__: + bases = list(ns0.IncorrectHostInformation_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.IncorrectHostInformation_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IndependentDiskVMotionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IndependentDiskVMotionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IndependentDiskVMotionNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFeatureNotSupported_Def not in ns0.IndependentDiskVMotionNotSupported_Def.__bases__: + bases = list(ns0.IndependentDiskVMotionNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFeatureNotSupported_Def) + ns0.IndependentDiskVMotionNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientCpuResourcesFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientCpuResourcesFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientCpuResourcesFault_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientCpuResourcesFault_Def.__bases__: + bases = list(ns0.InsufficientCpuResourcesFault_Def.__bases__) + bases.insert(0, ns0.InsufficientResourcesFault_Def) + ns0.InsufficientCpuResourcesFault_Def.__bases__ = tuple(bases) + + ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientFailoverResourcesFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientFailoverResourcesFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientFailoverResourcesFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientFailoverResourcesFault_Def.__bases__: + bases = list(ns0.InsufficientFailoverResourcesFault_Def.__bases__) + bases.insert(0, ns0.InsufficientResourcesFault_Def) + ns0.InsufficientFailoverResourcesFault_Def.__bases__ = tuple(bases) + + ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientHostCapacityFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientHostCapacityFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientHostCapacityFault_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientHostCapacityFault_Def.__bases__: + bases = list(ns0.InsufficientHostCapacityFault_Def.__bases__) + bases.insert(0, ns0.InsufficientResourcesFault_Def) + ns0.InsufficientHostCapacityFault_Def.__bases__ = tuple(bases) + + ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientHostCpuCapacityFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientHostCpuCapacityFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientHostCpuCapacityFault_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientHostCpuCapacityFault_Def.__bases__: + bases = list(ns0.InsufficientHostCpuCapacityFault_Def.__bases__) + bases.insert(0, ns0.InsufficientHostCapacityFault_Def) + ns0.InsufficientHostCpuCapacityFault_Def.__bases__ = tuple(bases) + + ns0.InsufficientHostCapacityFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientHostMemoryCapacityFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientHostMemoryCapacityFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientHostMemoryCapacityFault_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientHostMemoryCapacityFault_Def.__bases__: + bases = list(ns0.InsufficientHostMemoryCapacityFault_Def.__bases__) + bases.insert(0, ns0.InsufficientHostCapacityFault_Def) + ns0.InsufficientHostMemoryCapacityFault_Def.__bases__ = tuple(bases) + + ns0.InsufficientHostCapacityFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientMemoryResourcesFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientMemoryResourcesFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientMemoryResourcesFault_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientMemoryResourcesFault_Def.__bases__: + bases = list(ns0.InsufficientMemoryResourcesFault_Def.__bases__) + bases.insert(0, ns0.InsufficientResourcesFault_Def) + ns0.InsufficientMemoryResourcesFault_Def.__bases__ = tuple(bases) + + ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientPerCpuCapacity_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientPerCpuCapacity") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientPerCpuCapacity_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientPerCpuCapacity_Def.__bases__: + bases = list(ns0.InsufficientPerCpuCapacity_Def.__bases__) + bases.insert(0, ns0.InsufficientHostCapacityFault_Def) + ns0.InsufficientPerCpuCapacity_Def.__bases__ = tuple(bases) + + ns0.InsufficientHostCapacityFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientResourcesFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientResourcesFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientResourcesFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InsufficientResourcesFault_Def.__bases__: + bases = list(ns0.InsufficientResourcesFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InsufficientResourcesFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientStandbyCpuResource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientStandbyCpuResource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientStandbyCpuResource_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientStandbyResource_Def not in ns0.InsufficientStandbyCpuResource_Def.__bases__: + bases = list(ns0.InsufficientStandbyCpuResource_Def.__bases__) + bases.insert(0, ns0.InsufficientStandbyResource_Def) + ns0.InsufficientStandbyCpuResource_Def.__bases__ = tuple(bases) + + ns0.InsufficientStandbyResource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientStandbyMemoryResource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientStandbyMemoryResource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientStandbyMemoryResource_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientStandbyResource_Def not in ns0.InsufficientStandbyMemoryResource_Def.__bases__: + bases = list(ns0.InsufficientStandbyMemoryResource_Def.__bases__) + bases.insert(0, ns0.InsufficientStandbyResource_Def) + ns0.InsufficientStandbyMemoryResource_Def.__bases__ = tuple(bases) + + ns0.InsufficientStandbyResource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InsufficientStandbyResource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InsufficientStandbyResource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InsufficientStandbyResource_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientStandbyResource_Def.__bases__: + bases = list(ns0.InsufficientStandbyResource_Def.__bases__) + bases.insert(0, ns0.InsufficientResourcesFault_Def) + ns0.InsufficientStandbyResource_Def.__bases__ = tuple(bases) + + ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidAffinitySettingFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidAffinitySettingFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidAffinitySettingFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidAffinitySettingFault_Def.__bases__: + bases = list(ns0.InvalidAffinitySettingFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidAffinitySettingFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidBmcRole_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidBmcRole") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidBmcRole_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidBmcRole_Def.__bases__: + bases = list(ns0.InvalidBmcRole_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidBmcRole_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidBundle_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidBundle") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidBundle_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PlatformConfigFault_Def not in ns0.InvalidBundle_Def.__bases__: + bases = list(ns0.InvalidBundle_Def.__bases__) + bases.insert(0, ns0.PlatformConfigFault_Def) + ns0.InvalidBundle_Def.__bases__ = tuple(bases) + + ns0.PlatformConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidClientCertificate_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidClientCertificate") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidClientCertificate_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidLogin_Def not in ns0.InvalidClientCertificate_Def.__bases__: + bases = list(ns0.InvalidClientCertificate_Def.__bases__) + bases.insert(0, ns0.InvalidLogin_Def) + ns0.InvalidClientCertificate_Def.__bases__ = tuple(bases) + + ns0.InvalidLogin_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidController_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"controllerKey"), aname="_controllerKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.InvalidController_Def.__bases__: + bases = list(ns0.InvalidController_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.InvalidController_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidDatastore_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidDatastore") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidDatastore_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidDatastore_Def.__bases__: + bases = list(ns0.InvalidDatastore_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidDatastore_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidDatastorePath_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidDatastorePath") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidDatastorePath_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDatastore_Def not in ns0.InvalidDatastorePath_Def.__bases__: + bases = list(ns0.InvalidDatastorePath_Def.__bases__) + bases.insert(0, ns0.InvalidDatastore_Def) + ns0.InvalidDatastorePath_Def.__bases__ = tuple(bases) + + ns0.InvalidDatastore_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidDeviceBacking_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidDeviceBacking") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidDeviceBacking_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.InvalidDeviceBacking_Def.__bases__: + bases = list(ns0.InvalidDeviceBacking_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.InvalidDeviceBacking_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidDeviceOperation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidDeviceOperation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidDeviceOperation_Def.schema + TClist = [GTD("urn:vim25","VirtualDeviceConfigSpecOperation",lazy=True)(pname=(ns,"badOp"), aname="_badOp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConfigSpecFileOperation",lazy=True)(pname=(ns,"badFileOp"), aname="_badFileOp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.InvalidDeviceOperation_Def.__bases__: + bases = list(ns0.InvalidDeviceOperation_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.InvalidDeviceOperation_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidDeviceSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidDeviceSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidDeviceSpec_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"deviceIndex"), aname="_deviceIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidVmConfig_Def not in ns0.InvalidDeviceSpec_Def.__bases__: + bases = list(ns0.InvalidDeviceSpec_Def.__bases__) + bases.insert(0, ns0.InvalidVmConfig_Def) + ns0.InvalidDeviceSpec_Def.__bases__ = tuple(bases) + + ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidDiskFormat_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidDiskFormat") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidDiskFormat_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidFormat_Def not in ns0.InvalidDiskFormat_Def.__bases__: + bases = list(ns0.InvalidDiskFormat_Def.__bases__) + bases.insert(0, ns0.InvalidFormat_Def) + ns0.InvalidDiskFormat_Def.__bases__ = tuple(bases) + + ns0.InvalidFormat_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidDrsBehaviorForFtVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidDrsBehaviorForFtVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidDrsBehaviorForFtVm_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidArgument_Def not in ns0.InvalidDrsBehaviorForFtVm_Def.__bases__: + bases = list(ns0.InvalidDrsBehaviorForFtVm_Def.__bases__) + bases.insert(0, ns0.InvalidArgument_Def) + ns0.InvalidDrsBehaviorForFtVm_Def.__bases__ = tuple(bases) + + ns0.InvalidArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidEditionLicense_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidEditionLicense") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidEditionLicense_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.InvalidEditionLicense_Def.__bases__: + bases = list(ns0.InvalidEditionLicense_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.InvalidEditionLicense_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidEvent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidEvent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidEvent_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidEvent_Def.__bases__: + bases = list(ns0.InvalidEvent_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidEvent_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidFolder_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidFolder") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidFolder_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidFolder_Def.__bases__: + bases = list(ns0.InvalidFolder_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidFolder_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidFormat_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidFormat") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidFormat_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.InvalidFormat_Def.__bases__: + bases = list(ns0.InvalidFormat_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.InvalidFormat_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidHostState_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidHostState") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidHostState_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidState_Def not in ns0.InvalidHostState_Def.__bases__: + bases = list(ns0.InvalidHostState_Def.__bases__) + bases.insert(0, ns0.InvalidState_Def) + ns0.InvalidHostState_Def.__bases__ = tuple(bases) + + ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidIndexArgument_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidIndexArgument") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidIndexArgument_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidArgument_Def not in ns0.InvalidIndexArgument_Def.__bases__: + bases = list(ns0.InvalidIndexArgument_Def.__bases__) + bases.insert(0, ns0.InvalidArgument_Def) + ns0.InvalidIndexArgument_Def.__bases__ = tuple(bases) + + ns0.InvalidArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidIpmiLoginInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidIpmiLoginInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidIpmiLoginInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidIpmiLoginInfo_Def.__bases__: + bases = list(ns0.InvalidIpmiLoginInfo_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidIpmiLoginInfo_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidIpmiMacAddress_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidIpmiMacAddress") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidIpmiMacAddress_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userProvidedMacAddress"), aname="_userProvidedMacAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"observedMacAddress"), aname="_observedMacAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidIpmiMacAddress_Def.__bases__: + bases = list(ns0.InvalidIpmiMacAddress_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidIpmiMacAddress_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidLicense_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidLicense") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidLicense_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseContent"), aname="_licenseContent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidLicense_Def.__bases__: + bases = list(ns0.InvalidLicense_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidLicense_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidLocale_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidLocale") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidLocale_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidLocale_Def.__bases__: + bases = list(ns0.InvalidLocale_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidLocale_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidLogin_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidLogin") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidLogin_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidLogin_Def.__bases__: + bases = list(ns0.InvalidLogin_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidLogin_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidName_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidName_Def.__bases__: + bases = list(ns0.InvalidName_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidName_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidNasCredentials_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidNasCredentials") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidNasCredentials_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NasConfigFault_Def not in ns0.InvalidNasCredentials_Def.__bases__: + bases = list(ns0.InvalidNasCredentials_Def.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.InvalidNasCredentials_Def.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidNetworkInType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidNetworkInType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidNetworkInType_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppPropertyFault_Def not in ns0.InvalidNetworkInType_Def.__bases__: + bases = list(ns0.InvalidNetworkInType_Def.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.InvalidNetworkInType_Def.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidNetworkResource_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidNetworkResource") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidNetworkResource_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NasConfigFault_Def not in ns0.InvalidNetworkResource_Def.__bases__: + bases = list(ns0.InvalidNetworkResource_Def.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.InvalidNetworkResource_Def.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidOperationOnSecondaryVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidOperationOnSecondaryVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidOperationOnSecondaryVm_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.InvalidOperationOnSecondaryVm_Def.__bases__: + bases = list(ns0.InvalidOperationOnSecondaryVm_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.InvalidOperationOnSecondaryVm_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidPowerState_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidPowerState") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidPowerState_Def.schema + TClist = [GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"requestedState"), aname="_requestedState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"existingState"), aname="_existingState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidState_Def not in ns0.InvalidPowerState_Def.__bases__: + bases = list(ns0.InvalidPowerState_Def.__bases__) + bases.insert(0, ns0.InvalidState_Def) + ns0.InvalidPowerState_Def.__bases__ = tuple(bases) + + ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidPrivilege_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidPrivilege") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidPrivilege_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"privilege"), aname="_privilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidPrivilege_Def.__bases__: + bases = list(ns0.InvalidPrivilege_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidPrivilege_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidPropertyType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidPropertyType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidPropertyType_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppPropertyFault_Def not in ns0.InvalidPropertyType_Def.__bases__: + bases = list(ns0.InvalidPropertyType_Def.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.InvalidPropertyType_Def.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidPropertyValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidPropertyValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidPropertyValue_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppPropertyFault_Def not in ns0.InvalidPropertyValue_Def.__bases__: + bases = list(ns0.InvalidPropertyValue_Def.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.InvalidPropertyValue_Def.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidResourcePoolStructureFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidResourcePoolStructureFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidResourcePoolStructureFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InsufficientResourcesFault_Def not in ns0.InvalidResourcePoolStructureFault_Def.__bases__: + bases = list(ns0.InvalidResourcePoolStructureFault_Def.__bases__) + bases.insert(0, ns0.InsufficientResourcesFault_Def) + ns0.InvalidResourcePoolStructureFault_Def.__bases__ = tuple(bases) + + ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidSnapshotFormat_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidSnapshotFormat") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidSnapshotFormat_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidFormat_Def not in ns0.InvalidSnapshotFormat_Def.__bases__: + bases = list(ns0.InvalidSnapshotFormat_Def.__bases__) + bases.insert(0, ns0.InvalidFormat_Def) + ns0.InvalidSnapshotFormat_Def.__bases__ = tuple(bases) + + ns0.InvalidFormat_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidState_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidState") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidState_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.InvalidState_Def.__bases__: + bases = list(ns0.InvalidState_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.InvalidState_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InvalidVmConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InvalidVmConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InvalidVmConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.InvalidVmConfig_Def.__bases__: + bases = list(ns0.InvalidVmConfig_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.InvalidVmConfig_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InventoryHasStandardAloneHosts_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "InventoryHasStandardAloneHosts") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.InventoryHasStandardAloneHosts_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hosts"), aname="_hosts", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.InventoryHasStandardAloneHosts_Def.__bases__: + bases = list(ns0.InventoryHasStandardAloneHosts_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.InventoryHasStandardAloneHosts_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IpHostnameGeneratorError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IpHostnameGeneratorError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IpHostnameGeneratorError_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.IpHostnameGeneratorError_Def.__bases__: + bases = list(ns0.IpHostnameGeneratorError_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.IpHostnameGeneratorError_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LegacyNetworkInterfaceInUse_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LegacyNetworkInterfaceInUse") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LegacyNetworkInterfaceInUse_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessNetwork_Def not in ns0.LegacyNetworkInterfaceInUse_Def.__bases__: + bases = list(ns0.LegacyNetworkInterfaceInUse_Def.__bases__) + bases.insert(0, ns0.CannotAccessNetwork_Def) + ns0.LegacyNetworkInterfaceInUse_Def.__bases__ = tuple(bases) + + ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseAssignmentFailedReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LicenseAssignmentFailedReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LicenseAssignmentFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseAssignmentFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseAssignmentFailed_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.LicenseAssignmentFailed_Def.__bases__: + bases = list(ns0.LicenseAssignmentFailed_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.LicenseAssignmentFailed_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseDowngradeDisallowed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseDowngradeDisallowed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseDowngradeDisallowed_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"edition"), aname="_edition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"features"), aname="_features", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.LicenseDowngradeDisallowed_Def.__bases__: + bases = list(ns0.LicenseDowngradeDisallowed_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.LicenseDowngradeDisallowed_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseExpired_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseExpired") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseExpired_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.LicenseExpired_Def.__bases__: + bases = list(ns0.LicenseExpired_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.LicenseExpired_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseKeyEntityMismatch_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseKeyEntityMismatch") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseKeyEntityMismatch_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.LicenseKeyEntityMismatch_Def.__bases__: + bases = list(ns0.LicenseKeyEntityMismatch_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.LicenseKeyEntityMismatch_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseRestricted_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseRestricted") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseRestricted_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.LicenseRestricted_Def.__bases__: + bases = list(ns0.LicenseRestricted_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.LicenseRestricted_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseServerUnavailable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseServerUnavailable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseServerUnavailable_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.LicenseServerUnavailable_Def.__bases__: + bases = list(ns0.LicenseServerUnavailable_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.LicenseServerUnavailable_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LicenseSourceUnavailable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LicenseSourceUnavailable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LicenseSourceUnavailable_Def.schema + TClist = [GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"licenseSource"), aname="_licenseSource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.LicenseSourceUnavailable_Def.__bases__: + bases = list(ns0.LicenseSourceUnavailable_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.LicenseSourceUnavailable_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LimitExceeded_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LimitExceeded") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LimitExceeded_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"limit"), aname="_limit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.LimitExceeded_Def.__bases__: + bases = list(ns0.LimitExceeded_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.LimitExceeded_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LinuxVolumeNotClean_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LinuxVolumeNotClean") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LinuxVolumeNotClean_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.LinuxVolumeNotClean_Def.__bases__: + bases = list(ns0.LinuxVolumeNotClean_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.LinuxVolumeNotClean_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LogBundlingFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LogBundlingFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LogBundlingFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.LogBundlingFailed_Def.__bases__: + bases = list(ns0.LogBundlingFailed_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.LogBundlingFailed_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MaintenanceModeFileMove_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MaintenanceModeFileMove") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MaintenanceModeFileMove_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.MaintenanceModeFileMove_Def.__bases__: + bases = list(ns0.MaintenanceModeFileMove_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.MaintenanceModeFileMove_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MemoryHotPlugNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MemoryHotPlugNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MemoryHotPlugNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.MemoryHotPlugNotSupported_Def.__bases__: + bases = list(ns0.MemoryHotPlugNotSupported_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.MemoryHotPlugNotSupported_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MemorySizeNotRecommended_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MemorySizeNotRecommended") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MemorySizeNotRecommended_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"memorySizeMB"), aname="_memorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"minMemorySizeMB"), aname="_minMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemorySizeMB"), aname="_maxMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.MemorySizeNotRecommended_Def.__bases__: + bases = list(ns0.MemorySizeNotRecommended_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.MemorySizeNotRecommended_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MemorySizeNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MemorySizeNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MemorySizeNotSupported_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"memorySizeMB"), aname="_memorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"minMemorySizeMB"), aname="_minMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemorySizeMB"), aname="_maxMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.MemorySizeNotSupported_Def.__bases__: + bases = list(ns0.MemorySizeNotSupported_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.MemorySizeNotSupported_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MemorySnapshotOnIndependentDisk_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MemorySnapshotOnIndependentDisk") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MemorySnapshotOnIndependentDisk_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.MemorySnapshotOnIndependentDisk_Def.__bases__: + bases = list(ns0.MemorySnapshotOnIndependentDisk_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.MemorySnapshotOnIndependentDisk_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MethodDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MethodDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MethodDisabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RuntimeFault_Def not in ns0.MethodDisabled_Def.__bases__: + bases = list(ns0.MethodDisabled_Def.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.MethodDisabled_Def.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationDisabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.MigrationDisabled_Def.__bases__: + bases = list(ns0.MigrationDisabled_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.MigrationDisabled_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.MigrationFault_Def.__bases__: + bases = list(ns0.MigrationFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.MigrationFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationFeatureNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationFeatureNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationFeatureNotSupported_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"atSourceHost"), aname="_atSourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"failedHostName"), aname="_failedHostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"failedHost"), aname="_failedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.MigrationFeatureNotSupported_Def.__bases__: + bases = list(ns0.MigrationFeatureNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.MigrationFeatureNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MigrationNotReady_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MigrationNotReady") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MigrationNotReady_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.MigrationNotReady_Def.__bases__: + bases = list(ns0.MigrationNotReady_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.MigrationNotReady_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MismatchedBundle_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MismatchedBundle") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MismatchedBundle_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"bundleUuid"), aname="_bundleUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostUuid"), aname="_hostUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"bundleBuildNumber"), aname="_bundleBuildNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostBuildNumber"), aname="_hostBuildNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.MismatchedBundle_Def.__bases__: + bases = list(ns0.MismatchedBundle_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.MismatchedBundle_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MismatchedNetworkPolicies_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MismatchedNetworkPolicies") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MismatchedNetworkPolicies_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.MismatchedNetworkPolicies_Def.__bases__: + bases = list(ns0.MismatchedNetworkPolicies_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.MismatchedNetworkPolicies_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MismatchedVMotionNetworkNames_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MismatchedVMotionNetworkNames") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MismatchedVMotionNetworkNames_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"sourceNetwork"), aname="_sourceNetwork", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destNetwork"), aname="_destNetwork", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.MismatchedVMotionNetworkNames_Def.__bases__: + bases = list(ns0.MismatchedVMotionNetworkNames_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.MismatchedVMotionNetworkNames_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MissingBmcSupport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingBmcSupport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingBmcSupport_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.MissingBmcSupport_Def.__bases__: + bases = list(ns0.MissingBmcSupport_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.MissingBmcSupport_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MissingController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidDeviceSpec_Def not in ns0.MissingController_Def.__bases__: + bases = list(ns0.MissingController_Def.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.MissingController_Def.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MissingLinuxCustResources_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingLinuxCustResources") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingLinuxCustResources_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.MissingLinuxCustResources_Def.__bases__: + bases = list(ns0.MissingLinuxCustResources_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.MissingLinuxCustResources_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MissingNetworkIpConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingNetworkIpConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingNetworkIpConfig_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppPropertyFault_Def not in ns0.MissingNetworkIpConfig_Def.__bases__: + bases = list(ns0.MissingNetworkIpConfig_Def.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.MissingNetworkIpConfig_Def.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MissingPowerOffConfiguration_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingPowerOffConfiguration") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingPowerOffConfiguration_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppConfigFault_Def not in ns0.MissingPowerOffConfiguration_Def.__bases__: + bases = list(ns0.MissingPowerOffConfiguration_Def.__bases__) + bases.insert(0, ns0.VAppConfigFault_Def) + ns0.MissingPowerOffConfiguration_Def.__bases__ = tuple(bases) + + ns0.VAppConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MissingPowerOnConfiguration_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingPowerOnConfiguration") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingPowerOnConfiguration_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppConfigFault_Def not in ns0.MissingPowerOnConfiguration_Def.__bases__: + bases = list(ns0.MissingPowerOnConfiguration_Def.__bases__) + bases.insert(0, ns0.VAppConfigFault_Def) + ns0.MissingPowerOnConfiguration_Def.__bases__ = tuple(bases) + + ns0.VAppConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MissingWindowsCustResources_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MissingWindowsCustResources") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MissingWindowsCustResources_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.MissingWindowsCustResources_Def.__bases__: + bases = list(ns0.MissingWindowsCustResources_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.MissingWindowsCustResources_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MountError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MountError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MountError_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"diskIndex"), aname="_diskIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.MountError_Def.__bases__: + bases = list(ns0.MountError_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.MountError_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MultipleCertificatesVerifyFaultThumbprintData_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MultipleCertificatesVerifyFaultThumbprintData") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"thumbprint"), aname="_thumbprint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.__bases__: + bases = list(ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfMultipleCertificatesVerifyFaultThumbprintData_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfMultipleCertificatesVerifyFaultThumbprintData") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfMultipleCertificatesVerifyFaultThumbprintData_Def.schema + TClist = [GTD("urn:vim25","MultipleCertificatesVerifyFaultThumbprintData",lazy=True)(pname=(ns,"MultipleCertificatesVerifyFaultThumbprintData"), aname="_MultipleCertificatesVerifyFaultThumbprintData", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._MultipleCertificatesVerifyFaultThumbprintData = [] + return + Holder.__name__ = "ArrayOfMultipleCertificatesVerifyFaultThumbprintData_Holder" + self.pyclass = Holder + + class MultipleCertificatesVerifyFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MultipleCertificatesVerifyFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MultipleCertificatesVerifyFault_Def.schema + TClist = [GTD("urn:vim25","MultipleCertificatesVerifyFaultThumbprintData",lazy=True)(pname=(ns,"thumbprintData"), aname="_thumbprintData", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.MultipleCertificatesVerifyFault_Def.__bases__: + bases = list(ns0.MultipleCertificatesVerifyFault_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.MultipleCertificatesVerifyFault_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MultipleSnapshotsNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MultipleSnapshotsNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MultipleSnapshotsNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.MultipleSnapshotsNotSupported_Def.__bases__: + bases = list(ns0.MultipleSnapshotsNotSupported_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.MultipleSnapshotsNotSupported_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NasConfigFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NasConfigFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NasConfigFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.NasConfigFault_Def.__bases__: + bases = list(ns0.NasConfigFault_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.NasConfigFault_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NasConnectionLimitReached_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NasConnectionLimitReached") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NasConnectionLimitReached_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NasConfigFault_Def not in ns0.NasConnectionLimitReached_Def.__bases__: + bases = list(ns0.NasConnectionLimitReached_Def.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.NasConnectionLimitReached_Def.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NasSessionCredentialConflict_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NasSessionCredentialConflict") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NasSessionCredentialConflict_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NasConfigFault_Def not in ns0.NasSessionCredentialConflict_Def.__bases__: + bases = list(ns0.NasSessionCredentialConflict_Def.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.NasSessionCredentialConflict_Def.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NasVolumeNotMounted_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NasVolumeNotMounted") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NasVolumeNotMounted_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NasConfigFault_Def not in ns0.NasVolumeNotMounted_Def.__bases__: + bases = list(ns0.NasVolumeNotMounted_Def.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.NasVolumeNotMounted_Def.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NetworkCopyFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworkCopyFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworkCopyFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.NetworkCopyFault_Def.__bases__: + bases = list(ns0.NetworkCopyFault_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.NetworkCopyFault_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NetworkInaccessible_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworkInaccessible") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworkInaccessible_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NasConfigFault_Def not in ns0.NetworkInaccessible_Def.__bases__: + bases = list(ns0.NetworkInaccessible_Def.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.NetworkInaccessible_Def.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NetworksMayNotBeTheSame_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworksMayNotBeTheSame") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworksMayNotBeTheSame_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.NetworksMayNotBeTheSame_Def.__bases__: + bases = list(ns0.NetworksMayNotBeTheSame_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.NetworksMayNotBeTheSame_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NicSettingMismatch_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NicSettingMismatch") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NicSettingMismatch_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numberOfNicsInSpec"), aname="_numberOfNicsInSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numberOfNicsInVM"), aname="_numberOfNicsInVM", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.NicSettingMismatch_Def.__bases__: + bases = list(ns0.NicSettingMismatch_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.NicSettingMismatch_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoActiveHostInCluster_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoActiveHostInCluster") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoActiveHostInCluster_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"computeResource"), aname="_computeResource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidState_Def not in ns0.NoActiveHostInCluster_Def.__bases__: + bases = list(ns0.NoActiveHostInCluster_Def.__bases__) + bases.insert(0, ns0.InvalidState_Def) + ns0.NoActiveHostInCluster_Def.__bases__ = tuple(bases) + + ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoAvailableIp_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoAvailableIp") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoAvailableIp_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppPropertyFault_Def not in ns0.NoAvailableIp_Def.__bases__: + bases = list(ns0.NoAvailableIp_Def.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.NoAvailableIp_Def.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoClientCertificate_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoClientCertificate") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoClientCertificate_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.NoClientCertificate_Def.__bases__: + bases = list(ns0.NoClientCertificate_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.NoClientCertificate_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoCompatibleHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoCompatibleHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoCompatibleHost_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.NoCompatibleHost_Def.__bases__: + bases = list(ns0.NoCompatibleHost_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.NoCompatibleHost_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoDiskFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoDiskFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoDiskFound_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.NoDiskFound_Def.__bases__: + bases = list(ns0.NoDiskFound_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.NoDiskFound_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoDiskSpace_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoDiskSpace") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoDiskSpace_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileFault_Def not in ns0.NoDiskSpace_Def.__bases__: + bases = list(ns0.NoDiskSpace_Def.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.NoDiskSpace_Def.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoDisksToCustomize_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoDisksToCustomize") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoDisksToCustomize_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.NoDisksToCustomize_Def.__bases__: + bases = list(ns0.NoDisksToCustomize_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.NoDisksToCustomize_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoGateway_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoGateway") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoGateway_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.NoGateway_Def.__bases__: + bases = list(ns0.NoGateway_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.NoGateway_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoGuestHeartbeat_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoGuestHeartbeat") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoGuestHeartbeat_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.NoGuestHeartbeat_Def.__bases__: + bases = list(ns0.NoGuestHeartbeat_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.NoGuestHeartbeat_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoHost_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.NoHost_Def.__bases__: + bases = list(ns0.NoHost_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.NoHost_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoHostSuitableForFtSecondary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoHostSuitableForFtSecondary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoHostSuitableForFtSecondary_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.NoHostSuitableForFtSecondary_Def.__bases__: + bases = list(ns0.NoHostSuitableForFtSecondary_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.NoHostSuitableForFtSecondary_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoLicenseServerConfigured_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoLicenseServerConfigured") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoLicenseServerConfigured_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.NoLicenseServerConfigured_Def.__bases__: + bases = list(ns0.NoLicenseServerConfigured_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.NoLicenseServerConfigured_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoPeerHostFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoPeerHostFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoPeerHostFound_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostPowerOpFailed_Def not in ns0.NoPeerHostFound_Def.__bases__: + bases = list(ns0.NoPeerHostFound_Def.__bases__) + bases.insert(0, ns0.HostPowerOpFailed_Def) + ns0.NoPeerHostFound_Def.__bases__ = tuple(bases) + + ns0.HostPowerOpFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoPermission_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoPermission") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoPermission_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"object"), aname="_object", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privilegeId"), aname="_privilegeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SecurityError_Def not in ns0.NoPermission_Def.__bases__: + bases = list(ns0.NoPermission_Def.__bases__) + bases.insert(0, ns0.SecurityError_Def) + ns0.NoPermission_Def.__bases__ = tuple(bases) + + ns0.SecurityError_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoPermissionOnHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoPermissionOnHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoPermissionOnHost_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.NoPermissionOnHost_Def.__bases__: + bases = list(ns0.NoPermissionOnHost_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.NoPermissionOnHost_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoPermissionOnNasVolume_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoPermissionOnNasVolume") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoPermissionOnNasVolume_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NasConfigFault_Def not in ns0.NoPermissionOnNasVolume_Def.__bases__: + bases = list(ns0.NoPermissionOnNasVolume_Def.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.NoPermissionOnNasVolume_Def.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoSubjectName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoSubjectName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoSubjectName_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.NoSubjectName_Def.__bases__: + bases = list(ns0.NoSubjectName_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.NoSubjectName_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoVcManagedIpConfigured_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoVcManagedIpConfigured") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoVcManagedIpConfigured_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppPropertyFault_Def not in ns0.NoVcManagedIpConfigured_Def.__bases__: + bases = list(ns0.NoVcManagedIpConfigured_Def.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.NoVcManagedIpConfigured_Def.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoVirtualNic_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoVirtualNic") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoVirtualNic_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.NoVirtualNic_Def.__bases__: + bases = list(ns0.NoVirtualNic_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.NoVirtualNic_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NoVmInVApp_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NoVmInVApp") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NoVmInVApp_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppConfigFault_Def not in ns0.NoVmInVApp_Def.__bases__: + bases = list(ns0.NoVmInVApp_Def.__bases__) + bases.insert(0, ns0.VAppConfigFault_Def) + ns0.NoVmInVApp_Def.__bases__ = tuple(bases) + + ns0.VAppConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NonHomeRDMVMotionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NonHomeRDMVMotionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NonHomeRDMVMotionNotSupported_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFeatureNotSupported_Def not in ns0.NonHomeRDMVMotionNotSupported_Def.__bases__: + bases = list(ns0.NonHomeRDMVMotionNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFeatureNotSupported_Def) + ns0.NonHomeRDMVMotionNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NonPersistentDisksNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NonPersistentDisksNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NonPersistentDisksNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.NonPersistentDisksNotSupported_Def.__bases__: + bases = list(ns0.NonPersistentDisksNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.NonPersistentDisksNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotAuthenticated_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotAuthenticated") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotAuthenticated_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NoPermission_Def not in ns0.NotAuthenticated_Def.__bases__: + bases = list(ns0.NotAuthenticated_Def.__bases__) + bases.insert(0, ns0.NoPermission_Def) + ns0.NotAuthenticated_Def.__bases__ = tuple(bases) + + ns0.NoPermission_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotEnoughCpus_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotEnoughCpus") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotEnoughCpus_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numCpuDest"), aname="_numCpuDest", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuVm"), aname="_numCpuVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.NotEnoughCpus_Def.__bases__: + bases = list(ns0.NotEnoughCpus_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.NotEnoughCpus_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotEnoughLogicalCpus_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotEnoughLogicalCpus") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotEnoughLogicalCpus_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughCpus_Def not in ns0.NotEnoughLogicalCpus_Def.__bases__: + bases = list(ns0.NotEnoughLogicalCpus_Def.__bases__) + bases.insert(0, ns0.NotEnoughCpus_Def) + ns0.NotEnoughLogicalCpus_Def.__bases__ = tuple(bases) + + ns0.NotEnoughCpus_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotFound_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.NotFound_Def.__bases__: + bases = list(ns0.NotFound_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.NotFound_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotSupportedHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotSupportedHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotSupportedHost_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"productName"), aname="_productName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productVersion"), aname="_productVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.NotSupportedHost_Def.__bases__: + bases = list(ns0.NotSupportedHost_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.NotSupportedHost_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotSupportedHostInCluster_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotSupportedHostInCluster") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotSupportedHostInCluster_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotSupportedHost_Def not in ns0.NotSupportedHostInCluster_Def.__bases__: + bases = list(ns0.NotSupportedHostInCluster_Def.__bases__) + bases.insert(0, ns0.NotSupportedHost_Def) + ns0.NotSupportedHostInCluster_Def.__bases__ = tuple(bases) + + ns0.NotSupportedHost_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NotUserConfigurableProperty_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NotUserConfigurableProperty") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NotUserConfigurableProperty_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VAppPropertyFault_Def not in ns0.NotUserConfigurableProperty_Def.__bases__: + bases = list(ns0.NotUserConfigurableProperty_Def.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.NotUserConfigurableProperty_Def.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NumVirtualCpusIncompatibleReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "NumVirtualCpusIncompatibleReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class NumVirtualCpusIncompatible_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NumVirtualCpusIncompatible") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NumVirtualCpusIncompatible_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpu"), aname="_numCpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.NumVirtualCpusIncompatible_Def.__bases__: + bases = list(ns0.NumVirtualCpusIncompatible_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.NumVirtualCpusIncompatible_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NumVirtualCpusNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NumVirtualCpusNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NumVirtualCpusNotSupported_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"maxSupportedVcpusDest"), aname="_maxSupportedVcpusDest", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuVm"), aname="_numCpuVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.NumVirtualCpusNotSupported_Def.__bases__: + bases = list(ns0.NumVirtualCpusNotSupported_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.NumVirtualCpusNotSupported_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OutOfBounds_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OutOfBounds") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OutOfBounds_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"argumentName"), aname="_argumentName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.OutOfBounds_Def.__bases__: + bases = list(ns0.OutOfBounds_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.OutOfBounds_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfAttribute_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfAttribute") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfAttribute_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"attributeName"), aname="_attributeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidPackage_Def not in ns0.OvfAttribute_Def.__bases__: + bases = list(ns0.OvfAttribute_Def.__bases__) + bases.insert(0, ns0.OvfInvalidPackage_Def) + ns0.OvfAttribute_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfConnectedDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfConnectedDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfConnectedDevice_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfHardwareExport_Def not in ns0.OvfConnectedDevice_Def.__bases__: + bases = list(ns0.OvfConnectedDevice_Def.__bases__) + bases.insert(0, ns0.OvfHardwareExport_Def) + ns0.OvfConnectedDevice_Def.__bases__ = tuple(bases) + + ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfConnectedDeviceFloppy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfConnectedDeviceFloppy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfConnectedDeviceFloppy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfConnectedDevice_Def not in ns0.OvfConnectedDeviceFloppy_Def.__bases__: + bases = list(ns0.OvfConnectedDeviceFloppy_Def.__bases__) + bases.insert(0, ns0.OvfConnectedDevice_Def) + ns0.OvfConnectedDeviceFloppy_Def.__bases__ = tuple(bases) + + ns0.OvfConnectedDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfConnectedDeviceIso_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfConnectedDeviceIso") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfConnectedDeviceIso_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfConnectedDevice_Def not in ns0.OvfConnectedDeviceIso_Def.__bases__: + bases = list(ns0.OvfConnectedDeviceIso_Def.__bases__) + bases.insert(0, ns0.OvfConnectedDevice_Def) + ns0.OvfConnectedDeviceIso_Def.__bases__ = tuple(bases) + + ns0.OvfConnectedDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfDiskMappingNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfDiskMappingNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfDiskMappingNotFound_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskName"), aname="_diskName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfSystemFault_Def not in ns0.OvfDiskMappingNotFound_Def.__bases__: + bases = list(ns0.OvfDiskMappingNotFound_Def.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfDiskMappingNotFound_Def.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfDuplicateElement_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfDuplicateElement") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfDuplicateElement_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfElement_Def not in ns0.OvfDuplicateElement_Def.__bases__: + bases = list(ns0.OvfDuplicateElement_Def.__bases__) + bases.insert(0, ns0.OvfElement_Def) + ns0.OvfDuplicateElement_Def.__bases__ = tuple(bases) + + ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfDuplicatedElementBoundary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfDuplicatedElementBoundary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfDuplicatedElementBoundary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"boundary"), aname="_boundary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfElement_Def not in ns0.OvfDuplicatedElementBoundary_Def.__bases__: + bases = list(ns0.OvfDuplicatedElementBoundary_Def.__bases__) + bases.insert(0, ns0.OvfElement_Def) + ns0.OvfDuplicatedElementBoundary_Def.__bases__ = tuple(bases) + + ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfElement_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfElement") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfElement_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidPackage_Def not in ns0.OvfElement_Def.__bases__: + bases = list(ns0.OvfElement_Def.__bases__) + bases.insert(0, ns0.OvfInvalidPackage_Def) + ns0.OvfElement_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfElementInvalidValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfElementInvalidValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfElementInvalidValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfElement_Def not in ns0.OvfElementInvalidValue_Def.__bases__: + bases = list(ns0.OvfElementInvalidValue_Def.__bases__) + bases.insert(0, ns0.OvfElement_Def) + ns0.OvfElementInvalidValue_Def.__bases__ = tuple(bases) + + ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfExport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfExport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfExport_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfFault_Def not in ns0.OvfExport_Def.__bases__: + bases = list(ns0.OvfExport_Def.__bases__) + bases.insert(0, ns0.OvfFault_Def) + ns0.OvfExport_Def.__bases__ = tuple(bases) + + ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.OvfFault_Def.__bases__: + bases = list(ns0.OvfFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.OvfFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfHardwareCheck_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfHardwareCheck") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfHardwareCheck_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfImport_Def not in ns0.OvfHardwareCheck_Def.__bases__: + bases = list(ns0.OvfHardwareCheck_Def.__bases__) + bases.insert(0, ns0.OvfImport_Def) + ns0.OvfHardwareCheck_Def.__bases__ = tuple(bases) + + ns0.OvfImport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfHardwareExport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfHardwareExport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfHardwareExport_Def.schema + TClist = [GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmPath"), aname="_vmPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfExport_Def not in ns0.OvfHardwareExport_Def.__bases__: + bases = list(ns0.OvfHardwareExport_Def.__bases__) + bases.insert(0, ns0.OvfExport_Def) + ns0.OvfHardwareExport_Def.__bases__ = tuple(bases) + + ns0.OvfExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfHostValueNotParsed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfHostValueNotParsed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfHostValueNotParsed_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfSystemFault_Def not in ns0.OvfHostValueNotParsed_Def.__bases__: + bases = list(ns0.OvfHostValueNotParsed_Def.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfHostValueNotParsed_Def.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfImport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfImport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfImport_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfFault_Def not in ns0.OvfImport_Def.__bases__: + bases = list(ns0.OvfImport_Def.__bases__) + bases.insert(0, ns0.OvfFault_Def) + ns0.OvfImport_Def.__bases__ = tuple(bases) + + ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfInvalidPackage_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfInvalidPackage") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfInvalidPackage_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineNumber"), aname="_lineNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfFault_Def not in ns0.OvfInvalidPackage_Def.__bases__: + bases = list(ns0.OvfInvalidPackage_Def.__bases__) + bases.insert(0, ns0.OvfFault_Def) + ns0.OvfInvalidPackage_Def.__bases__ = tuple(bases) + + ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfInvalidValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfInvalidValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfInvalidValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfAttribute_Def not in ns0.OvfInvalidValue_Def.__bases__: + bases = list(ns0.OvfInvalidValue_Def.__bases__) + bases.insert(0, ns0.OvfAttribute_Def) + ns0.OvfInvalidValue_Def.__bases__ = tuple(bases) + + ns0.OvfAttribute_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfInvalidValueConfiguration_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfInvalidValueConfiguration") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfInvalidValueConfiguration_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueConfiguration_Def.__bases__: + bases = list(ns0.OvfInvalidValueConfiguration_Def.__bases__) + bases.insert(0, ns0.OvfInvalidValue_Def) + ns0.OvfInvalidValueConfiguration_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfInvalidValueEmpty_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfInvalidValueEmpty") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfInvalidValueEmpty_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueEmpty_Def.__bases__: + bases = list(ns0.OvfInvalidValueEmpty_Def.__bases__) + bases.insert(0, ns0.OvfInvalidValue_Def) + ns0.OvfInvalidValueEmpty_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfInvalidValueFormatMalformed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfInvalidValueFormatMalformed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfInvalidValueFormatMalformed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueFormatMalformed_Def.__bases__: + bases = list(ns0.OvfInvalidValueFormatMalformed_Def.__bases__) + bases.insert(0, ns0.OvfInvalidValue_Def) + ns0.OvfInvalidValueFormatMalformed_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfInvalidValueReference_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfInvalidValueReference") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfInvalidValueReference_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueReference_Def.__bases__: + bases = list(ns0.OvfInvalidValueReference_Def.__bases__) + bases.insert(0, ns0.OvfInvalidValue_Def) + ns0.OvfInvalidValueReference_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfInvalidVmName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfInvalidVmName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfInvalidVmName_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfInvalidVmName_Def.__bases__: + bases = list(ns0.OvfInvalidVmName_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfInvalidVmName_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfMappedOsId_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfMappedOsId") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfMappedOsId_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"ovfId"), aname="_ovfId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescription"), aname="_ovfDescription", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"targetDescription"), aname="_targetDescription", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfImport_Def not in ns0.OvfMappedOsId_Def.__bases__: + bases = list(ns0.OvfMappedOsId_Def.__bases__) + bases.insert(0, ns0.OvfImport_Def) + ns0.OvfMappedOsId_Def.__bases__ = tuple(bases) + + ns0.OvfImport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfMissingAttribute_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfMissingAttribute") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfMissingAttribute_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfAttribute_Def not in ns0.OvfMissingAttribute_Def.__bases__: + bases = list(ns0.OvfMissingAttribute_Def.__bases__) + bases.insert(0, ns0.OvfAttribute_Def) + ns0.OvfMissingAttribute_Def.__bases__ = tuple(bases) + + ns0.OvfAttribute_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfMissingElement_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfMissingElement") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfMissingElement_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfElement_Def not in ns0.OvfMissingElement_Def.__bases__: + bases = list(ns0.OvfMissingElement_Def.__bases__) + bases.insert(0, ns0.OvfElement_Def) + ns0.OvfMissingElement_Def.__bases__ = tuple(bases) + + ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfMissingElementNormalBoundary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfMissingElementNormalBoundary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfMissingElementNormalBoundary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"boundary"), aname="_boundary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfMissingElement_Def not in ns0.OvfMissingElementNormalBoundary_Def.__bases__: + bases = list(ns0.OvfMissingElementNormalBoundary_Def.__bases__) + bases.insert(0, ns0.OvfMissingElement_Def) + ns0.OvfMissingElementNormalBoundary_Def.__bases__ = tuple(bases) + + ns0.OvfMissingElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfMissingHardware_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfMissingHardware") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfMissingHardware_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"resourceType"), aname="_resourceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfImport_Def not in ns0.OvfMissingHardware_Def.__bases__: + bases = list(ns0.OvfMissingHardware_Def.__bases__) + bases.insert(0, ns0.OvfImport_Def) + ns0.OvfMissingHardware_Def.__bases__ = tuple(bases) + + ns0.OvfImport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfNoHostNic_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfNoHostNic") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfNoHostNic_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfNoHostNic_Def.__bases__: + bases = list(ns0.OvfNoHostNic_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfNoHostNic_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfNoSupportedHardwareFamily_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfNoSupportedHardwareFamily") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfNoSupportedHardwareFamily_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfNoSupportedHardwareFamily_Def.__bases__: + bases = list(ns0.OvfNoSupportedHardwareFamily_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfNoSupportedHardwareFamily_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfProperty_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfProperty") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfProperty_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidPackage_Def not in ns0.OvfProperty_Def.__bases__: + bases = list(ns0.OvfProperty_Def.__bases__) + bases.insert(0, ns0.OvfInvalidPackage_Def) + ns0.OvfProperty_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfPropertyExport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfPropertyExport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfPropertyExport_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfExport_Def not in ns0.OvfPropertyExport_Def.__bases__: + bases = list(ns0.OvfPropertyExport_Def.__bases__) + bases.insert(0, ns0.OvfExport_Def) + ns0.OvfPropertyExport_Def.__bases__ = tuple(bases) + + ns0.OvfExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfPropertyNetwork_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfPropertyNetwork") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfPropertyNetwork_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfProperty_Def not in ns0.OvfPropertyNetwork_Def.__bases__: + bases = list(ns0.OvfPropertyNetwork_Def.__bases__) + bases.insert(0, ns0.OvfProperty_Def) + ns0.OvfPropertyNetwork_Def.__bases__ = tuple(bases) + + ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfPropertyQualifier_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfPropertyQualifier") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfPropertyQualifier_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"qualifier"), aname="_qualifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfProperty_Def not in ns0.OvfPropertyQualifier_Def.__bases__: + bases = list(ns0.OvfPropertyQualifier_Def.__bases__) + bases.insert(0, ns0.OvfProperty_Def) + ns0.OvfPropertyQualifier_Def.__bases__ = tuple(bases) + + ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfPropertyQualifierDuplicate_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfPropertyQualifierDuplicate") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfPropertyQualifierDuplicate_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"qualifier"), aname="_qualifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfProperty_Def not in ns0.OvfPropertyQualifierDuplicate_Def.__bases__: + bases = list(ns0.OvfPropertyQualifierDuplicate_Def.__bases__) + bases.insert(0, ns0.OvfProperty_Def) + ns0.OvfPropertyQualifierDuplicate_Def.__bases__ = tuple(bases) + + ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfPropertyQualifierIgnored_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfPropertyQualifierIgnored") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfPropertyQualifierIgnored_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"qualifier"), aname="_qualifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfProperty_Def not in ns0.OvfPropertyQualifierIgnored_Def.__bases__: + bases = list(ns0.OvfPropertyQualifierIgnored_Def.__bases__) + bases.insert(0, ns0.OvfProperty_Def) + ns0.OvfPropertyQualifierIgnored_Def.__bases__ = tuple(bases) + + ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfPropertyType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfPropertyType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfPropertyType_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfProperty_Def not in ns0.OvfPropertyType_Def.__bases__: + bases = list(ns0.OvfPropertyType_Def.__bases__) + bases.insert(0, ns0.OvfProperty_Def) + ns0.OvfPropertyType_Def.__bases__ = tuple(bases) + + ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfPropertyValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfPropertyValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfPropertyValue_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfProperty_Def not in ns0.OvfPropertyValue_Def.__bases__: + bases = list(ns0.OvfPropertyValue_Def.__bases__) + bases.insert(0, ns0.OvfProperty_Def) + ns0.OvfPropertyValue_Def.__bases__ = tuple(bases) + + ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfSystemFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfSystemFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfSystemFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfFault_Def not in ns0.OvfSystemFault_Def.__bases__: + bases = list(ns0.OvfSystemFault_Def.__bases__) + bases.insert(0, ns0.OvfFault_Def) + ns0.OvfSystemFault_Def.__bases__ = tuple(bases) + + ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfToXmlUnsupportedElement_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfToXmlUnsupportedElement") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfToXmlUnsupportedElement_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfSystemFault_Def not in ns0.OvfToXmlUnsupportedElement_Def.__bases__: + bases = list(ns0.OvfToXmlUnsupportedElement_Def.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfToXmlUnsupportedElement_Def.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnableToExportDisk_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnableToExportDisk") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnableToExportDisk_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskName"), aname="_diskName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfHardwareExport_Def not in ns0.OvfUnableToExportDisk_Def.__bases__: + bases = list(ns0.OvfUnableToExportDisk_Def.__bases__) + bases.insert(0, ns0.OvfHardwareExport_Def) + ns0.OvfUnableToExportDisk_Def.__bases__ = tuple(bases) + + ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnexpectedElement_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnexpectedElement") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnexpectedElement_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfElement_Def not in ns0.OvfUnexpectedElement_Def.__bases__: + bases = list(ns0.OvfUnexpectedElement_Def.__bases__) + bases.insert(0, ns0.OvfElement_Def) + ns0.OvfUnexpectedElement_Def.__bases__ = tuple(bases) + + ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnknownDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnknownDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnknownDevice_Def.schema + TClist = [GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfSystemFault_Def not in ns0.OvfUnknownDevice_Def.__bases__: + bases = list(ns0.OvfUnknownDevice_Def.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfUnknownDevice_Def.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnknownDeviceBacking_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnknownDeviceBacking") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnknownDeviceBacking_Def.schema + TClist = [GTD("urn:vim25","VirtualDeviceBackingInfo",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfHardwareExport_Def not in ns0.OvfUnknownDeviceBacking_Def.__bases__: + bases = list(ns0.OvfUnknownDeviceBacking_Def.__bases__) + bases.insert(0, ns0.OvfHardwareExport_Def) + ns0.OvfUnknownDeviceBacking_Def.__bases__ = tuple(bases) + + ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnknownEntity_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnknownEntity") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnknownEntity_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineNumber"), aname="_lineNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfSystemFault_Def not in ns0.OvfUnknownEntity_Def.__bases__: + bases = list(ns0.OvfUnknownEntity_Def.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfUnknownEntity_Def.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedAttribute_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedAttribute") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedAttribute_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"attributeName"), aname="_attributeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedAttribute_Def.__bases__: + bases = list(ns0.OvfUnsupportedAttribute_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfUnsupportedAttribute_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedAttributeValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedAttributeValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedAttributeValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedAttribute_Def not in ns0.OvfUnsupportedAttributeValue_Def.__bases__: + bases = list(ns0.OvfUnsupportedAttributeValue_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedAttribute_Def) + ns0.OvfUnsupportedAttributeValue_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedAttribute_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedDeviceBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backingName"), aname="_backingName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfSystemFault_Def not in ns0.OvfUnsupportedDeviceBackingInfo_Def.__bases__: + bases = list(ns0.OvfUnsupportedDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfUnsupportedDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedDeviceBackingOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backingName"), aname="_backingName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfSystemFault_Def not in ns0.OvfUnsupportedDeviceBackingOption_Def.__bases__: + bases = list(ns0.OvfUnsupportedDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfUnsupportedDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedDeviceExport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedDeviceExport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedDeviceExport_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfHardwareExport_Def not in ns0.OvfUnsupportedDeviceExport_Def.__bases__: + bases = list(ns0.OvfUnsupportedDeviceExport_Def.__bases__) + bases.insert(0, ns0.OvfHardwareExport_Def) + ns0.OvfUnsupportedDeviceExport_Def.__bases__ = tuple(bases) + + ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedElement_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedElement") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedElement_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedElement_Def.__bases__: + bases = list(ns0.OvfUnsupportedElement_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfUnsupportedElement_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedElementValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedElementValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedElementValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedElement_Def not in ns0.OvfUnsupportedElementValue_Def.__bases__: + bases = list(ns0.OvfUnsupportedElementValue_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedElement_Def) + ns0.OvfUnsupportedElementValue_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedPackage_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedPackage") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedPackage_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineNumber"), aname="_lineNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfFault_Def not in ns0.OvfUnsupportedPackage_Def.__bases__: + bases = list(ns0.OvfUnsupportedPackage_Def.__bases__) + bases.insert(0, ns0.OvfFault_Def) + ns0.OvfUnsupportedPackage_Def.__bases__ = tuple(bases) + + ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedSection_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedSection") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedSection_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedElement_Def not in ns0.OvfUnsupportedSection_Def.__bases__: + bases = list(ns0.OvfUnsupportedSection_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedElement_Def) + ns0.OvfUnsupportedSection_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedSubType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedSubType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedSubType_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceType"), aname="_deviceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceSubType"), aname="_deviceSubType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedSubType_Def.__bases__: + bases = list(ns0.OvfUnsupportedSubType_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfUnsupportedSubType_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfUnsupportedType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfUnsupportedType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfUnsupportedType_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceType"), aname="_deviceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedType_Def.__bases__: + bases = list(ns0.OvfUnsupportedType_Def.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfUnsupportedType_Def.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfWrongElement_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfWrongElement") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfWrongElement_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfElement_Def not in ns0.OvfWrongElement_Def.__bases__: + bases = list(ns0.OvfWrongElement_Def.__bases__) + bases.insert(0, ns0.OvfElement_Def) + ns0.OvfWrongElement_Def.__bases__ = tuple(bases) + + ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfWrongNamespace_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfWrongNamespace") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfWrongNamespace_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"namespaceName"), aname="_namespaceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidPackage_Def not in ns0.OvfWrongNamespace_Def.__bases__: + bases = list(ns0.OvfWrongNamespace_Def.__bases__) + bases.insert(0, ns0.OvfInvalidPackage_Def) + ns0.OvfWrongNamespace_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OvfXmlFormat_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OvfXmlFormat") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OvfXmlFormat_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OvfInvalidPackage_Def not in ns0.OvfXmlFormat_Def.__bases__: + bases = list(ns0.OvfXmlFormat_Def.__bases__) + bases.insert(0, ns0.OvfInvalidPackage_Def) + ns0.OvfXmlFormat_Def.__bases__ = tuple(bases) + + ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchAlreadyInstalled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchAlreadyInstalled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchAlreadyInstalled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PatchNotApplicable_Def not in ns0.PatchAlreadyInstalled_Def.__bases__: + bases = list(ns0.PatchAlreadyInstalled_Def.__bases__) + bases.insert(0, ns0.PatchNotApplicable_Def) + ns0.PatchAlreadyInstalled_Def.__bases__ = tuple(bases) + + ns0.PatchNotApplicable_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchBinariesNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchBinariesNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchBinariesNotFound_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"patchID"), aname="_patchID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"binary"), aname="_binary", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.PatchBinariesNotFound_Def.__bases__: + bases = list(ns0.PatchBinariesNotFound_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.PatchBinariesNotFound_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchInstallFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchInstallFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchInstallFailed_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"rolledBack"), aname="_rolledBack", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PlatformConfigFault_Def not in ns0.PatchInstallFailed_Def.__bases__: + bases = list(ns0.PatchInstallFailed_Def.__bases__) + bases.insert(0, ns0.PlatformConfigFault_Def) + ns0.PatchInstallFailed_Def.__bases__ = tuple(bases) + + ns0.PlatformConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchIntegrityError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchIntegrityError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchIntegrityError_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PlatformConfigFault_Def not in ns0.PatchIntegrityError_Def.__bases__: + bases = list(ns0.PatchIntegrityError_Def.__bases__) + bases.insert(0, ns0.PlatformConfigFault_Def) + ns0.PatchIntegrityError_Def.__bases__ = tuple(bases) + + ns0.PlatformConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchMetadataCorrupted_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchMetadataCorrupted") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchMetadataCorrupted_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PatchMetadataInvalid_Def not in ns0.PatchMetadataCorrupted_Def.__bases__: + bases = list(ns0.PatchMetadataCorrupted_Def.__bases__) + bases.insert(0, ns0.PatchMetadataInvalid_Def) + ns0.PatchMetadataCorrupted_Def.__bases__ = tuple(bases) + + ns0.PatchMetadataInvalid_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchMetadataInvalid_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchMetadataInvalid") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchMetadataInvalid_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"patchID"), aname="_patchID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaData"), aname="_metaData", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.PatchMetadataInvalid_Def.__bases__: + bases = list(ns0.PatchMetadataInvalid_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.PatchMetadataInvalid_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchMetadataNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchMetadataNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchMetadataNotFound_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PatchMetadataInvalid_Def not in ns0.PatchMetadataNotFound_Def.__bases__: + bases = list(ns0.PatchMetadataNotFound_Def.__bases__) + bases.insert(0, ns0.PatchMetadataInvalid_Def) + ns0.PatchMetadataNotFound_Def.__bases__ = tuple(bases) + + ns0.PatchMetadataInvalid_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchMissingDependencies_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchMissingDependencies") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchMissingDependencies_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"prerequisitePatch"), aname="_prerequisitePatch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"prerequisiteLib"), aname="_prerequisiteLib", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PatchNotApplicable_Def not in ns0.PatchMissingDependencies_Def.__bases__: + bases = list(ns0.PatchMissingDependencies_Def.__bases__) + bases.insert(0, ns0.PatchNotApplicable_Def) + ns0.PatchMissingDependencies_Def.__bases__ = tuple(bases) + + ns0.PatchNotApplicable_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchNotApplicable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchNotApplicable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchNotApplicable_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"patchID"), aname="_patchID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.PatchNotApplicable_Def.__bases__: + bases = list(ns0.PatchNotApplicable_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.PatchNotApplicable_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PatchSuperseded_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PatchSuperseded") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PatchSuperseded_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"supersede"), aname="_supersede", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PatchNotApplicable_Def not in ns0.PatchSuperseded_Def.__bases__: + bases = list(ns0.PatchSuperseded_Def.__bases__) + bases.insert(0, ns0.PatchNotApplicable_Def) + ns0.PatchSuperseded_Def.__bases__ = tuple(bases) + + ns0.PatchNotApplicable_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PhysCompatRDMNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysCompatRDMNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysCompatRDMNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RDMNotSupported_Def not in ns0.PhysCompatRDMNotSupported_Def.__bases__: + bases = list(ns0.PhysCompatRDMNotSupported_Def.__bases__) + bases.insert(0, ns0.RDMNotSupported_Def) + ns0.PhysCompatRDMNotSupported_Def.__bases__ = tuple(bases) + + ns0.RDMNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PlatformConfigFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PlatformConfigFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PlatformConfigFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"text"), aname="_text", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.PlatformConfigFault_Def.__bases__: + bases = list(ns0.PlatformConfigFault_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.PlatformConfigFault_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PowerOnFtSecondaryFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PowerOnFtSecondaryFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PowerOnFtSecondaryFailed_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FtIssuesOnHostHostSelectionType",lazy=True)(pname=(ns,"hostSelectionBy"), aname="_hostSelectionBy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"hostErrors"), aname="_hostErrors", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"rootCause"), aname="_rootCause", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.PowerOnFtSecondaryFailed_Def.__bases__: + bases = list(ns0.PowerOnFtSecondaryFailed_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.PowerOnFtSecondaryFailed_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PowerOnFtSecondaryTimedout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PowerOnFtSecondaryTimedout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PowerOnFtSecondaryTimedout_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.Timedout_Def not in ns0.PowerOnFtSecondaryTimedout_Def.__bases__: + bases = list(ns0.PowerOnFtSecondaryTimedout_Def.__bases__) + bases.insert(0, ns0.Timedout_Def) + ns0.PowerOnFtSecondaryTimedout_Def.__bases__ = tuple(bases) + + ns0.Timedout_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileUpdateFailedUpdateFailure_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileUpdateFailedUpdateFailure") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileUpdateFailedUpdateFailure_Def.schema + TClist = [GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"profilePath"), aname="_profilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"errMsg"), aname="_errMsg", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileUpdateFailedUpdateFailure_Def.__bases__: + bases = list(ns0.ProfileUpdateFailedUpdateFailure_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileUpdateFailedUpdateFailure_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileUpdateFailedUpdateFailure_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileUpdateFailedUpdateFailure") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileUpdateFailedUpdateFailure_Def.schema + TClist = [GTD("urn:vim25","ProfileUpdateFailedUpdateFailure",lazy=True)(pname=(ns,"ProfileUpdateFailedUpdateFailure"), aname="_ProfileUpdateFailedUpdateFailure", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileUpdateFailedUpdateFailure = [] + return + Holder.__name__ = "ArrayOfProfileUpdateFailedUpdateFailure_Holder" + self.pyclass = Holder + + class ProfileUpdateFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileUpdateFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileUpdateFailed_Def.schema + TClist = [GTD("urn:vim25","ProfileUpdateFailedUpdateFailure",lazy=True)(pname=(ns,"failure"), aname="_failure", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.ProfileUpdateFailed_Def.__bases__: + bases = list(ns0.ProfileUpdateFailed_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.ProfileUpdateFailed_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RDMConversionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RDMConversionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RDMConversionNotSupported_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.RDMConversionNotSupported_Def.__bases__: + bases = list(ns0.RDMConversionNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.RDMConversionNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RDMNotPreserved_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RDMNotPreserved") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RDMNotPreserved_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.RDMNotPreserved_Def.__bases__: + bases = list(ns0.RDMNotPreserved_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.RDMNotPreserved_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RDMNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RDMNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RDMNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.RDMNotSupported_Def.__bases__: + bases = list(ns0.RDMNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.RDMNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RDMNotSupportedOnDatastore_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RDMNotSupportedOnDatastore") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RDMNotSupportedOnDatastore_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastoreName"), aname="_datastoreName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.RDMNotSupportedOnDatastore_Def.__bases__: + bases = list(ns0.RDMNotSupportedOnDatastore_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.RDMNotSupportedOnDatastore_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RDMPointsToInaccessibleDisk_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RDMPointsToInaccessibleDisk") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RDMPointsToInaccessibleDisk_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessVmDisk_Def not in ns0.RDMPointsToInaccessibleDisk_Def.__bases__: + bases = list(ns0.RDMPointsToInaccessibleDisk_Def.__bases__) + bases.insert(0, ns0.CannotAccessVmDisk_Def) + ns0.RDMPointsToInaccessibleDisk_Def.__bases__ = tuple(bases) + + ns0.CannotAccessVmDisk_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RawDiskNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RawDiskNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RawDiskNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.RawDiskNotSupported_Def.__bases__: + bases = list(ns0.RawDiskNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.RawDiskNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReadOnlyDisksWithLegacyDestination_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ReadOnlyDisksWithLegacyDestination") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ReadOnlyDisksWithLegacyDestination_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"roDiskCount"), aname="_roDiskCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"timeoutDanger"), aname="_timeoutDanger", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.ReadOnlyDisksWithLegacyDestination_Def.__bases__: + bases = list(ns0.ReadOnlyDisksWithLegacyDestination_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.ReadOnlyDisksWithLegacyDestination_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RebootRequired_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RebootRequired") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RebootRequired_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"patch"), aname="_patch", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.RebootRequired_Def.__bases__: + bases = list(ns0.RebootRequired_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.RebootRequired_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RecordReplayDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RecordReplayDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RecordReplayDisabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.RecordReplayDisabled_Def.__bases__: + bases = list(ns0.RecordReplayDisabled_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.RecordReplayDisabled_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RemoteDeviceNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RemoteDeviceNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RemoteDeviceNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.RemoteDeviceNotSupported_Def.__bases__: + bases = list(ns0.RemoteDeviceNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.RemoteDeviceNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RemoveFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RemoveFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RemoveFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.RemoveFailed_Def.__bases__: + bases = list(ns0.RemoveFailed_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.RemoveFailed_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourceInUse_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourceInUse") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourceInUse_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.ResourceInUse_Def.__bases__: + bases = list(ns0.ResourceInUse_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.ResourceInUse_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ResourceNotAvailable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ResourceNotAvailable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ResourceNotAvailable_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"containerType"), aname="_containerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"containerName"), aname="_containerName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.ResourceNotAvailable_Def.__bases__: + bases = list(ns0.ResourceNotAvailable_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.ResourceNotAvailable_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RestrictedVersion_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RestrictedVersion") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RestrictedVersion_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SecurityError_Def not in ns0.RestrictedVersion_Def.__bases__: + bases = list(ns0.RestrictedVersion_Def.__bases__) + bases.insert(0, ns0.SecurityError_Def) + ns0.RestrictedVersion_Def.__bases__ = tuple(bases) + + ns0.SecurityError_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RuleViolation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RuleViolation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RuleViolation_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.RuleViolation_Def.__bases__: + bases = list(ns0.RuleViolation_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.RuleViolation_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SSLDisabledFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SSLDisabledFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SSLDisabledFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.SSLDisabledFault_Def.__bases__: + bases = list(ns0.SSLDisabledFault_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.SSLDisabledFault_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SSLVerifyFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SSLVerifyFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SSLVerifyFault_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"selfSigned"), aname="_selfSigned", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"thumbprint"), aname="_thumbprint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.SSLVerifyFault_Def.__bases__: + bases = list(ns0.SSLVerifyFault_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.SSLVerifyFault_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SSPIChallenge_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SSPIChallenge") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SSPIChallenge_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"base64Token"), aname="_base64Token", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.SSPIChallenge_Def.__bases__: + bases = list(ns0.SSPIChallenge_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.SSPIChallenge_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SecondaryVmAlreadyDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SecondaryVmAlreadyDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SecondaryVmAlreadyDisabled_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmAlreadyDisabled_Def.__bases__: + bases = list(ns0.SecondaryVmAlreadyDisabled_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.SecondaryVmAlreadyDisabled_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SecondaryVmAlreadyEnabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SecondaryVmAlreadyEnabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SecondaryVmAlreadyEnabled_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmAlreadyEnabled_Def.__bases__: + bases = list(ns0.SecondaryVmAlreadyEnabled_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.SecondaryVmAlreadyEnabled_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SecondaryVmAlreadyRegistered_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SecondaryVmAlreadyRegistered") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SecondaryVmAlreadyRegistered_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmAlreadyRegistered_Def.__bases__: + bases = list(ns0.SecondaryVmAlreadyRegistered_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.SecondaryVmAlreadyRegistered_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SecondaryVmNotRegistered_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SecondaryVmNotRegistered") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SecondaryVmNotRegistered_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmNotRegistered_Def.__bases__: + bases = list(ns0.SecondaryVmNotRegistered_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.SecondaryVmNotRegistered_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SharedBusControllerNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SharedBusControllerNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SharedBusControllerNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.SharedBusControllerNotSupported_Def.__bases__: + bases = list(ns0.SharedBusControllerNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.SharedBusControllerNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotCloneNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotCloneNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotCloneNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotCloneNotSupported_Def.__bases__: + bases = list(ns0.SnapshotCloneNotSupported_Def.__bases__) + bases.insert(0, ns0.SnapshotCopyNotSupported_Def) + ns0.SnapshotCloneNotSupported_Def.__bases__ = tuple(bases) + + ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotCopyNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotCopyNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotCopyNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.SnapshotCopyNotSupported_Def.__bases__: + bases = list(ns0.SnapshotCopyNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.SnapshotCopyNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotDisabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.SnapshotDisabled_Def.__bases__: + bases = list(ns0.SnapshotDisabled_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.SnapshotDisabled_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.SnapshotFault_Def.__bases__: + bases = list(ns0.SnapshotFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.SnapshotFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotIncompatibleDeviceInVm_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotIncompatibleDeviceInVm") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotIncompatibleDeviceInVm_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.SnapshotIncompatibleDeviceInVm_Def.__bases__: + bases = list(ns0.SnapshotIncompatibleDeviceInVm_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.SnapshotIncompatibleDeviceInVm_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotLocked_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotLocked") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotLocked_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.SnapshotLocked_Def.__bases__: + bases = list(ns0.SnapshotLocked_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.SnapshotLocked_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotMoveFromNonHomeNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotMoveFromNonHomeNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotMoveFromNonHomeNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotMoveFromNonHomeNotSupported_Def.__bases__: + bases = list(ns0.SnapshotMoveFromNonHomeNotSupported_Def.__bases__) + bases.insert(0, ns0.SnapshotCopyNotSupported_Def) + ns0.SnapshotMoveFromNonHomeNotSupported_Def.__bases__ = tuple(bases) + + ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotMoveNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotMoveNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotMoveNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotMoveNotSupported_Def.__bases__: + bases = list(ns0.SnapshotMoveNotSupported_Def.__bases__) + bases.insert(0, ns0.SnapshotCopyNotSupported_Def) + ns0.SnapshotMoveNotSupported_Def.__bases__ = tuple(bases) + + ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotMoveToNonHomeNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotMoveToNonHomeNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotMoveToNonHomeNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotMoveToNonHomeNotSupported_Def.__bases__: + bases = list(ns0.SnapshotMoveToNonHomeNotSupported_Def.__bases__) + bases.insert(0, ns0.SnapshotCopyNotSupported_Def) + ns0.SnapshotMoveToNonHomeNotSupported_Def.__bases__ = tuple(bases) + + ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotNoChange_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotNoChange") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotNoChange_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.SnapshotNoChange_Def.__bases__: + bases = list(ns0.SnapshotNoChange_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.SnapshotNoChange_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SnapshotRevertIssue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SnapshotRevertIssue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SnapshotRevertIssue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"snapshotName"), aname="_snapshotName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Event",lazy=True)(pname=(ns,"event"), aname="_event", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"errors"), aname="_errors", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.SnapshotRevertIssue_Def.__bases__: + bases = list(ns0.SnapshotRevertIssue_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.SnapshotRevertIssue_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class StorageVMotionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "StorageVMotionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.StorageVMotionNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFeatureNotSupported_Def not in ns0.StorageVMotionNotSupported_Def.__bases__: + bases = list(ns0.StorageVMotionNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFeatureNotSupported_Def) + ns0.StorageVMotionNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SuspendedRelocateNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SuspendedRelocateNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SuspendedRelocateNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.SuspendedRelocateNotSupported_Def.__bases__: + bases = list(ns0.SuspendedRelocateNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.SuspendedRelocateNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SwapDatastoreNotWritableOnHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SwapDatastoreNotWritableOnHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SwapDatastoreNotWritableOnHost_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreNotWritableOnHost_Def not in ns0.SwapDatastoreNotWritableOnHost_Def.__bases__: + bases = list(ns0.SwapDatastoreNotWritableOnHost_Def.__bases__) + bases.insert(0, ns0.DatastoreNotWritableOnHost_Def) + ns0.SwapDatastoreNotWritableOnHost_Def.__bases__ = tuple(bases) + + ns0.DatastoreNotWritableOnHost_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SwapDatastoreUnset_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SwapDatastoreUnset") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SwapDatastoreUnset_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.SwapDatastoreUnset_Def.__bases__: + bases = list(ns0.SwapDatastoreUnset_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.SwapDatastoreUnset_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SwapPlacementOverrideNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SwapPlacementOverrideNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SwapPlacementOverrideNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidVmConfig_Def not in ns0.SwapPlacementOverrideNotSupported_Def.__bases__: + bases = list(ns0.SwapPlacementOverrideNotSupported_Def.__bases__) + bases.insert(0, ns0.InvalidVmConfig_Def) + ns0.SwapPlacementOverrideNotSupported_Def.__bases__ = tuple(bases) + + ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class SwitchNotInUpgradeMode_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SwitchNotInUpgradeMode") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SwitchNotInUpgradeMode_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsFault_Def not in ns0.SwitchNotInUpgradeMode_Def.__bases__: + bases = list(ns0.SwitchNotInUpgradeMode_Def.__bases__) + bases.insert(0, ns0.DvsFault_Def) + ns0.SwitchNotInUpgradeMode_Def.__bases__ = tuple(bases) + + ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TaskInProgress_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskInProgress") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskInProgress_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"task"), aname="_task", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.TaskInProgress_Def.__bases__: + bases = list(ns0.TaskInProgress_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.TaskInProgress_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class Timedout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "Timedout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.Timedout_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.Timedout_Def.__bases__: + bases = list(ns0.Timedout_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.Timedout_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TooManyConsecutiveOverrides_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TooManyConsecutiveOverrides") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TooManyConsecutiveOverrides_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.TooManyConsecutiveOverrides_Def.__bases__: + bases = list(ns0.TooManyConsecutiveOverrides_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.TooManyConsecutiveOverrides_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TooManyDevices_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TooManyDevices") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TooManyDevices_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidVmConfig_Def not in ns0.TooManyDevices_Def.__bases__: + bases = list(ns0.TooManyDevices_Def.__bases__) + bases.insert(0, ns0.InvalidVmConfig_Def) + ns0.TooManyDevices_Def.__bases__ = tuple(bases) + + ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TooManyDisksOnLegacyHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TooManyDisksOnLegacyHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TooManyDisksOnLegacyHost_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"diskCount"), aname="_diskCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"timeoutDanger"), aname="_timeoutDanger", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.TooManyDisksOnLegacyHost_Def.__bases__: + bases = list(ns0.TooManyDisksOnLegacyHost_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.TooManyDisksOnLegacyHost_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TooManyHosts_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TooManyHosts") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TooManyHosts_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectFault_Def not in ns0.TooManyHosts_Def.__bases__: + bases = list(ns0.TooManyHosts_Def.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.TooManyHosts_Def.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TooManySnapshotLevels_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TooManySnapshotLevels") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TooManySnapshotLevels_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.SnapshotFault_Def not in ns0.TooManySnapshotLevels_Def.__bases__: + bases = list(ns0.TooManySnapshotLevels_Def.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.TooManySnapshotLevels_Def.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ToolsAlreadyUpgraded_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsAlreadyUpgraded") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsAlreadyUpgraded_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsAlreadyUpgraded_Def.__bases__: + bases = list(ns0.ToolsAlreadyUpgraded_Def.__bases__) + bases.insert(0, ns0.VmToolsUpgradeFault_Def) + ns0.ToolsAlreadyUpgraded_Def.__bases__ = tuple(bases) + + ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ToolsAutoUpgradeNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsAutoUpgradeNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsAutoUpgradeNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsAutoUpgradeNotSupported_Def.__bases__: + bases = list(ns0.ToolsAutoUpgradeNotSupported_Def.__bases__) + bases.insert(0, ns0.VmToolsUpgradeFault_Def) + ns0.ToolsAutoUpgradeNotSupported_Def.__bases__ = tuple(bases) + + ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ToolsImageNotAvailable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsImageNotAvailable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsImageNotAvailable_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsImageNotAvailable_Def.__bases__: + bases = list(ns0.ToolsImageNotAvailable_Def.__bases__) + bases.insert(0, ns0.VmToolsUpgradeFault_Def) + ns0.ToolsImageNotAvailable_Def.__bases__ = tuple(bases) + + ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ToolsImageSignatureCheckFailed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsImageSignatureCheckFailed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsImageSignatureCheckFailed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsImageSignatureCheckFailed_Def.__bases__: + bases = list(ns0.ToolsImageSignatureCheckFailed_Def.__bases__) + bases.insert(0, ns0.VmToolsUpgradeFault_Def) + ns0.ToolsImageSignatureCheckFailed_Def.__bases__ = tuple(bases) + + ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ToolsInstallationInProgress_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsInstallationInProgress") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsInstallationInProgress_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.ToolsInstallationInProgress_Def.__bases__: + bases = list(ns0.ToolsInstallationInProgress_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.ToolsInstallationInProgress_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ToolsUnavailable_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsUnavailable") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsUnavailable_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.ToolsUnavailable_Def.__bases__: + bases = list(ns0.ToolsUnavailable_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.ToolsUnavailable_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ToolsUpgradeCancelled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsUpgradeCancelled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsUpgradeCancelled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsUpgradeCancelled_Def.__bases__: + bases = list(ns0.ToolsUpgradeCancelled_Def.__bases__) + bases.insert(0, ns0.VmToolsUpgradeFault_Def) + ns0.ToolsUpgradeCancelled_Def.__bases__ = tuple(bases) + + ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UncommittedUndoableDisk_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UncommittedUndoableDisk") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UncommittedUndoableDisk_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.UncommittedUndoableDisk_Def.__bases__: + bases = list(ns0.UncommittedUndoableDisk_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.UncommittedUndoableDisk_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnconfiguredPropertyValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnconfiguredPropertyValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnconfiguredPropertyValue_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidPropertyValue_Def not in ns0.UnconfiguredPropertyValue_Def.__bases__: + bases = list(ns0.UnconfiguredPropertyValue_Def.__bases__) + bases.insert(0, ns0.InvalidPropertyValue_Def) + ns0.UnconfiguredPropertyValue_Def.__bases__ = tuple(bases) + + ns0.InvalidPropertyValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UncustomizableGuest_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UncustomizableGuest") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UncustomizableGuest_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"uncustomizableGuestOS"), aname="_uncustomizableGuestOS", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.UncustomizableGuest_Def.__bases__: + bases = list(ns0.UncustomizableGuest_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.UncustomizableGuest_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnexpectedCustomizationFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnexpectedCustomizationFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnexpectedCustomizationFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.UnexpectedCustomizationFault_Def.__bases__: + bases = list(ns0.UnexpectedCustomizationFault_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.UnexpectedCustomizationFault_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnrecognizedHost_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnrecognizedHost") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnrecognizedHost_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.UnrecognizedHost_Def.__bases__: + bases = list(ns0.UnrecognizedHost_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.UnrecognizedHost_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnsharedSwapVMotionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnsharedSwapVMotionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnsharedSwapVMotionNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFeatureNotSupported_Def not in ns0.UnsharedSwapVMotionNotSupported_Def.__bases__: + bases = list(ns0.UnsharedSwapVMotionNotSupported_Def.__bases__) + bases.insert(0, ns0.MigrationFeatureNotSupported_Def) + ns0.UnsharedSwapVMotionNotSupported_Def.__bases__ = tuple(bases) + + ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnsupportedDatastore_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnsupportedDatastore") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnsupportedDatastore_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.UnsupportedDatastore_Def.__bases__: + bases = list(ns0.UnsupportedDatastore_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.UnsupportedDatastore_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnsupportedGuest_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnsupportedGuest") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnsupportedGuest_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"unsupportedGuestOS"), aname="_unsupportedGuestOS", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidVmConfig_Def not in ns0.UnsupportedGuest_Def.__bases__: + bases = list(ns0.UnsupportedGuest_Def.__bases__) + bases.insert(0, ns0.InvalidVmConfig_Def) + ns0.UnsupportedGuest_Def.__bases__ = tuple(bases) + + ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnsupportedVimApiVersion_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnsupportedVimApiVersion") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnsupportedVimApiVersion_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.UnsupportedVimApiVersion_Def.__bases__: + bases = list(ns0.UnsupportedVimApiVersion_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.UnsupportedVimApiVersion_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnsupportedVmxLocation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnsupportedVmxLocation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnsupportedVmxLocation_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.UnsupportedVmxLocation_Def.__bases__: + bases = list(ns0.UnsupportedVmxLocation_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.UnsupportedVmxLocation_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UnusedVirtualDiskBlocksNotScrubbed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UnusedVirtualDiskBlocksNotScrubbed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceBackingNotSupported_Def not in ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__bases__: + bases = list(ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__bases__) + bases.insert(0, ns0.DeviceBackingNotSupported_Def) + ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__bases__ = tuple(bases) + + ns0.DeviceBackingNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserNotFound_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserNotFound") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserNotFound_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unresolved"), aname="_unresolved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.UserNotFound_Def.__bases__: + bases = list(ns0.UserNotFound_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.UserNotFound_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppConfigFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppConfigFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppConfigFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.VAppConfigFault_Def.__bases__: + bases = list(ns0.VAppConfigFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.VAppConfigFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppNotRunning_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppNotRunning") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppNotRunning_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.VAppNotRunning_Def.__bases__: + bases = list(ns0.VAppNotRunning_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.VAppNotRunning_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppPropertyFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppPropertyFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppPropertyFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.VAppPropertyFault_Def.__bases__: + bases = list(ns0.VAppPropertyFault_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.VAppPropertyFault_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppTaskInProgress_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppTaskInProgress") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppTaskInProgress_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskInProgress_Def not in ns0.VAppTaskInProgress_Def.__bases__: + bases = list(ns0.VAppTaskInProgress_Def.__bases__) + bases.insert(0, ns0.TaskInProgress_Def) + ns0.VAppTaskInProgress_Def.__bases__ = tuple(bases) + + ns0.TaskInProgress_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMINotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMINotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMINotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.VMINotSupported_Def.__bases__: + bases = list(ns0.VMINotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.VMINotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMOnConflictDVPort_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMOnConflictDVPort") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMOnConflictDVPort_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessNetwork_Def not in ns0.VMOnConflictDVPort_Def.__bases__: + bases = list(ns0.VMOnConflictDVPort_Def.__bases__) + bases.insert(0, ns0.CannotAccessNetwork_Def) + ns0.VMOnConflictDVPort_Def.__bases__ = tuple(bases) + + ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMOnVirtualIntranet_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMOnVirtualIntranet") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMOnVirtualIntranet_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CannotAccessNetwork_Def not in ns0.VMOnVirtualIntranet_Def.__bases__: + bases = list(ns0.VMOnVirtualIntranet_Def.__bases__) + bases.insert(0, ns0.CannotAccessNetwork_Def) + ns0.VMOnVirtualIntranet_Def.__bases__ = tuple(bases) + + ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionInterfaceIssue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionInterfaceIssue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionInterfaceIssue_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"atSourceHost"), aname="_atSourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"failedHost"), aname="_failedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"failedHostEntity"), aname="_failedHostEntity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.VMotionInterfaceIssue_Def.__bases__: + bases = list(ns0.VMotionInterfaceIssue_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.VMotionInterfaceIssue_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionLinkCapacityLow_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionLinkCapacityLow") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionLinkCapacityLow_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionLinkCapacityLow_Def.__bases__: + bases = list(ns0.VMotionLinkCapacityLow_Def.__bases__) + bases.insert(0, ns0.VMotionInterfaceIssue_Def) + ns0.VMotionLinkCapacityLow_Def.__bases__ = tuple(bases) + + ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionLinkDown_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionLinkDown") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionLinkDown_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionLinkDown_Def.__bases__: + bases = list(ns0.VMotionLinkDown_Def.__bases__) + bases.insert(0, ns0.VMotionInterfaceIssue_Def) + ns0.VMotionLinkDown_Def.__bases__ = tuple(bases) + + ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionNotConfigured_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionNotConfigured") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionNotConfigured_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionNotConfigured_Def.__bases__: + bases = list(ns0.VMotionNotConfigured_Def.__bases__) + bases.insert(0, ns0.VMotionInterfaceIssue_Def) + ns0.VMotionNotConfigured_Def.__bases__ = tuple(bases) + + ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionNotLicensed_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionNotLicensed") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionNotLicensed_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionNotLicensed_Def.__bases__: + bases = list(ns0.VMotionNotLicensed_Def.__bases__) + bases.insert(0, ns0.VMotionInterfaceIssue_Def) + ns0.VMotionNotLicensed_Def.__bases__ = tuple(bases) + + ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionNotSupported_Def.__bases__: + bases = list(ns0.VMotionNotSupported_Def.__bases__) + bases.insert(0, ns0.VMotionInterfaceIssue_Def) + ns0.VMotionNotSupported_Def.__bases__ = tuple(bases) + + ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VMotionProtocolIncompatible_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VMotionProtocolIncompatible") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VMotionProtocolIncompatible_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.VMotionProtocolIncompatible_Def.__bases__: + bases = list(ns0.VMotionProtocolIncompatible_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.VMotionProtocolIncompatible_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VimFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VimFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VimFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MethodFault_Def not in ns0.VimFault_Def.__bases__: + bases = list(ns0.VimFault_Def.__bases__) + bases.insert(0, ns0.MethodFault_Def) + ns0.VimFault_Def.__bases__ = tuple(bases) + + ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskBlocksNotFullyProvisioned_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskBlocksNotFullyProvisioned") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskBlocksNotFullyProvisioned_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceBackingNotSupported_Def not in ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__bases__: + bases = list(ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__bases__) + bases.insert(0, ns0.DeviceBackingNotSupported_Def) + ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__bases__ = tuple(bases) + + ns0.DeviceBackingNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DeviceNotSupported_Def not in ns0.VirtualEthernetCardNotSupported_Def.__bases__: + bases = list(ns0.VirtualEthernetCardNotSupported_Def.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.VirtualEthernetCardNotSupported_Def.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualHardwareCompatibilityIssue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualHardwareCompatibilityIssue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualHardwareCompatibilityIssue_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.VirtualHardwareCompatibilityIssue_Def.__bases__: + bases = list(ns0.VirtualHardwareCompatibilityIssue_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.VirtualHardwareCompatibilityIssue_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualHardwareVersionNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualHardwareVersionNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualHardwareVersionNotSupported_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.VirtualHardwareVersionNotSupported_Def.__bases__: + bases = list(ns0.VirtualHardwareVersionNotSupported_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.VirtualHardwareVersionNotSupported_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmAlreadyExistsInDatacenter_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmAlreadyExistsInDatacenter") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmAlreadyExistsInDatacenter_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidFolder_Def not in ns0.VmAlreadyExistsInDatacenter_Def.__bases__: + bases = list(ns0.VmAlreadyExistsInDatacenter_Def.__bases__) + bases.insert(0, ns0.InvalidFolder_Def) + ns0.VmAlreadyExistsInDatacenter_Def.__bases__ = tuple(bases) + + ns0.InvalidFolder_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.VmConfigFault_Def.__bases__: + bases = list(ns0.VmConfigFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.VmConfigFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigIncompatibleForFaultTolerance_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigIncompatibleForFaultTolerance") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigIncompatibleForFaultTolerance_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.VmConfigIncompatibleForFaultTolerance_Def.__bases__: + bases = list(ns0.VmConfigIncompatibleForFaultTolerance_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.VmConfigIncompatibleForFaultTolerance_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigIncompatibleForRecordReplay_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigIncompatibleForRecordReplay") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigIncompatibleForRecordReplay_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFault_Def not in ns0.VmConfigIncompatibleForRecordReplay_Def.__bases__: + bases = list(ns0.VmConfigIncompatibleForRecordReplay_Def.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.VmConfigIncompatibleForRecordReplay_Def.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFaultToleranceConfigIssueReasonForIssue_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VmFaultToleranceConfigIssueReasonForIssue") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VmFaultToleranceConfigIssue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFaultToleranceConfigIssue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFaultToleranceConfigIssue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceConfigIssue_Def.__bases__: + bases = list(ns0.VmFaultToleranceConfigIssue_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.VmFaultToleranceConfigIssue_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFaultToleranceInvalidFileBackingDeviceType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VmFaultToleranceInvalidFileBackingDeviceType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VmFaultToleranceInvalidFileBacking_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFaultToleranceInvalidFileBacking") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFaultToleranceInvalidFileBacking_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"backingType"), aname="_backingType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backingFilename"), aname="_backingFilename", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceInvalidFileBacking_Def.__bases__: + bases = list(ns0.VmFaultToleranceInvalidFileBacking_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.VmFaultToleranceInvalidFileBacking_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFaultToleranceIssue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFaultToleranceIssue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFaultToleranceIssue_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.VmFaultToleranceIssue_Def.__bases__: + bases = list(ns0.VmFaultToleranceIssue_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.VmFaultToleranceIssue_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmFaultToleranceOpIssuesList_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmFaultToleranceOpIssuesList") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmFaultToleranceOpIssuesList_Def.schema + TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"errors"), aname="_errors", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warnings"), aname="_warnings", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceOpIssuesList_Def.__bases__: + bases = list(ns0.VmFaultToleranceOpIssuesList_Def.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.VmFaultToleranceOpIssuesList_Def.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmLimitLicense_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmLimitLicense") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmLimitLicense_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"limit"), aname="_limit", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.NotEnoughLicenses_Def not in ns0.VmLimitLicense_Def.__bases__: + bases = list(ns0.VmLimitLicense_Def.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.VmLimitLicense_Def.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmPowerOnDisabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmPowerOnDisabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmPowerOnDisabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidState_Def not in ns0.VmPowerOnDisabled_Def.__bases__: + bases = list(ns0.VmPowerOnDisabled_Def.__bases__) + bases.insert(0, ns0.InvalidState_Def) + ns0.VmPowerOnDisabled_Def.__bases__ = tuple(bases) + + ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmToolsUpgradeFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmToolsUpgradeFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmToolsUpgradeFault_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.VmToolsUpgradeFault_Def.__bases__: + bases = list(ns0.VmToolsUpgradeFault_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.VmToolsUpgradeFault_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmValidateMaxDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmValidateMaxDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmValidateMaxDevice_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"count"), aname="_count", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VimFault_Def not in ns0.VmValidateMaxDevice_Def.__bases__: + bases = list(ns0.VmValidateMaxDevice_Def.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.VmValidateMaxDevice_Def.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmWwnConflict_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmWwnConflict") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmWwnConflict_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"wwn"), aname="_wwn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.InvalidVmConfig_Def not in ns0.VmWwnConflict_Def.__bases__: + bases = list(ns0.VmWwnConflict_Def.__bases__) + bases.insert(0, ns0.InvalidVmConfig_Def) + ns0.VmWwnConflict_Def.__bases__ = tuple(bases) + + ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsAlreadyMounted_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsAlreadyMounted") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsAlreadyMounted_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsMountFault_Def not in ns0.VmfsAlreadyMounted_Def.__bases__: + bases = list(ns0.VmfsAlreadyMounted_Def.__bases__) + bases.insert(0, ns0.VmfsMountFault_Def) + ns0.VmfsAlreadyMounted_Def.__bases__ = tuple(bases) + + ns0.VmfsMountFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsAmbiguousMount_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsAmbiguousMount") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsAmbiguousMount_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsMountFault_Def not in ns0.VmfsAmbiguousMount_Def.__bases__: + bases = list(ns0.VmfsAmbiguousMount_Def.__bases__) + bases.insert(0, ns0.VmfsMountFault_Def) + ns0.VmfsAmbiguousMount_Def.__bases__ = tuple(bases) + + ns0.VmfsMountFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsMountFault_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsMountFault") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsMountFault_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConfigFault_Def not in ns0.VmfsMountFault_Def.__bases__: + bases = list(ns0.VmfsMountFault_Def.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.VmfsMountFault_Def.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmotionInterfaceNotEnabled_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmotionInterfaceNotEnabled") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmotionInterfaceNotEnabled_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostPowerOpFailed_Def not in ns0.VmotionInterfaceNotEnabled_Def.__bases__: + bases = list(ns0.VmotionInterfaceNotEnabled_Def.__bases__) + bases.insert(0, ns0.HostPowerOpFailed_Def) + ns0.VmotionInterfaceNotEnabled_Def.__bases__ = tuple(bases) + + ns0.HostPowerOpFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VolumeEditorError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VolumeEditorError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VolumeEditorError_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationFault_Def not in ns0.VolumeEditorError_Def.__bases__: + bases = list(ns0.VolumeEditorError_Def.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.VolumeEditorError_Def.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class WakeOnLanNotSupported_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "WakeOnLanNotSupported") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.WakeOnLanNotSupported_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.WakeOnLanNotSupported_Def.__bases__: + bases = list(ns0.WakeOnLanNotSupported_Def.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.WakeOnLanNotSupported_Def.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class WakeOnLanNotSupportedByVmotionNIC_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "WakeOnLanNotSupportedByVmotionNIC") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.WakeOnLanNotSupportedByVmotionNIC_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostPowerOpFailed_Def not in ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__bases__: + bases = list(ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__bases__) + bases.insert(0, ns0.HostPowerOpFailed_Def) + ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__bases__ = tuple(bases) + + ns0.HostPowerOpFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class WillModifyConfigCpuRequirements_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "WillModifyConfigCpuRequirements") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.WillModifyConfigCpuRequirements_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MigrationFault_Def not in ns0.WillModifyConfigCpuRequirements_Def.__bases__: + bases = list(ns0.WillModifyConfigCpuRequirements_Def.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.WillModifyConfigCpuRequirements_Def.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AutoStartAction_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AutoStartAction") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class AutoStartDefaults_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AutoStartDefaults") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AutoStartDefaults_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startDelay"), aname="_startDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"stopDelay"), aname="_stopDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"waitForHeartbeat"), aname="_waitForHeartbeat", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"stopAction"), aname="_stopAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AutoStartDefaults_Def.__bases__: + bases = list(ns0.AutoStartDefaults_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AutoStartDefaults_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AutoStartWaitHeartbeatSetting_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AutoStartWaitHeartbeatSetting") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class AutoStartPowerInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AutoStartPowerInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AutoStartPowerInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startOrder"), aname="_startOrder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startDelay"), aname="_startDelay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AutoStartWaitHeartbeatSetting",lazy=True)(pname=(ns,"waitForHeartbeat"), aname="_waitForHeartbeat", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"startAction"), aname="_startAction", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"stopDelay"), aname="_stopDelay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"stopAction"), aname="_stopAction", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.AutoStartPowerInfo_Def.__bases__: + bases = list(ns0.AutoStartPowerInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.AutoStartPowerInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfAutoStartPowerInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAutoStartPowerInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAutoStartPowerInfo_Def.schema + TClist = [GTD("urn:vim25","AutoStartPowerInfo",lazy=True)(pname=(ns,"AutoStartPowerInfo"), aname="_AutoStartPowerInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._AutoStartPowerInfo = [] + return + Holder.__name__ = "ArrayOfAutoStartPowerInfo_Holder" + self.pyclass = Holder + + class HostAutoStartManagerConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostAutoStartManagerConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostAutoStartManagerConfig_Def.schema + TClist = [GTD("urn:vim25","AutoStartDefaults",lazy=True)(pname=(ns,"defaults"), aname="_defaults", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AutoStartPowerInfo",lazy=True)(pname=(ns,"powerInfo"), aname="_powerInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostAutoStartManagerConfig_Def.__bases__: + bases = list(ns0.HostAutoStartManagerConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostAutoStartManagerConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReconfigureAutostartRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureAutostartRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureAutostartRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAutoStartManagerConfig",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "ReconfigureAutostartRequestType_Holder" + self.pyclass = Holder + + class AutoStartPowerOnRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AutoStartPowerOnRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AutoStartPowerOnRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "AutoStartPowerOnRequestType_Holder" + self.pyclass = Holder + + class AutoStartPowerOffRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AutoStartPowerOffRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AutoStartPowerOffRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "AutoStartPowerOffRequestType_Holder" + self.pyclass = Holder + + class HostBootDeviceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostBootDeviceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostBootDeviceInfo_Def.schema + TClist = [GTD("urn:vim25","HostBootDevice",lazy=True)(pname=(ns,"bootDevices"), aname="_bootDevices", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"currentBootDeviceKey"), aname="_currentBootDeviceKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostBootDeviceInfo_Def.__bases__: + bases = list(ns0.HostBootDeviceInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostBootDeviceInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostBootDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostBootDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostBootDevice_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostBootDevice_Def.__bases__: + bases = list(ns0.HostBootDevice_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostBootDevice_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostBootDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostBootDevice") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostBootDevice_Def.schema + TClist = [GTD("urn:vim25","HostBootDevice",lazy=True)(pname=(ns,"HostBootDevice"), aname="_HostBootDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostBootDevice = [] + return + Holder.__name__ = "ArrayOfHostBootDevice_Holder" + self.pyclass = Holder + + class QueryBootDevicesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryBootDevicesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryBootDevicesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryBootDevicesRequestType_Holder" + self.pyclass = Holder + + class UpdateBootDeviceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateBootDeviceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateBootDeviceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._key = None + return + Holder.__name__ = "UpdateBootDeviceRequestType_Holder" + self.pyclass = Holder + + class HostReplayUnsupportedReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostReplayUnsupportedReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostCapability_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCapability") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCapability_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"recursiveResourcePoolsSupported"), aname="_recursiveResourcePoolsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuMemoryResourceConfigurationSupported"), aname="_cpuMemoryResourceConfigurationSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rebootSupported"), aname="_rebootSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shutdownSupported"), aname="_shutdownSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmotionSupported"), aname="_vmotionSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"standbySupported"), aname="_standbySupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipmiSupported"), aname="_ipmiSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSupportedVMs"), aname="_maxSupportedVMs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxRunningVMs"), aname="_maxRunningVMs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSupportedVcpus"), aname="_maxSupportedVcpus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"datastorePrincipalSupported"), aname="_datastorePrincipalSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sanSupported"), aname="_sanSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"nfsSupported"), aname="_nfsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"iscsiSupported"), aname="_iscsiSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vlanTaggingSupported"), aname="_vlanTaggingSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"nicTeamingSupported"), aname="_nicTeamingSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"highGuestMemSupported"), aname="_highGuestMemSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"maintenanceModeSupported"), aname="_maintenanceModeSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suspendedRelocateSupported"), aname="_suspendedRelocateSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"restrictedSnapshotRelocateSupported"), aname="_restrictedSnapshotRelocateSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"perVmSwapFiles"), aname="_perVmSwapFiles", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"localSwapDatastoreSupported"), aname="_localSwapDatastoreSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unsharedSwapVMotionSupported"), aname="_unsharedSwapVMotionSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"backgroundSnapshotsSupported"), aname="_backgroundSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"preAssignedPCIUnitNumbersSupported"), aname="_preAssignedPCIUnitNumbersSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"screenshotSupported"), aname="_screenshotSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"scaledScreenshotSupported"), aname="_scaledScreenshotSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"storageVMotionSupported"), aname="_storageVMotionSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmotionWithStorageVMotionSupported"), aname="_vmotionWithStorageVMotionSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recordReplaySupported"), aname="_recordReplaySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ftSupported"), aname="_ftSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"replayUnsupportedReason"), aname="_replayUnsupportedReason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"loginBySSLThumbprintSupported"), aname="_loginBySSLThumbprintSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cloneFromSnapshotSupported"), aname="_cloneFromSnapshotSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deltaDiskBackingsSupported"), aname="_deltaDiskBackingsSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"perVMNetworkTrafficShapingSupported"), aname="_perVMNetworkTrafficShapingSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tpmSupported"), aname="_tpmSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"supportedCpuFeature"), aname="_supportedCpuFeature", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"virtualExecUsageSupported"), aname="_virtualExecUsageSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostCapability_Def.__bases__: + bases = list(ns0.HostCapability_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostCapability_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigChangeMode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostConfigChangeMode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostConfigChangeOperation_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostConfigChangeOperation") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostConfigChange_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigChange") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigChange_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConfigChange_Def.__bases__: + bases = list(ns0.HostConfigChange_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConfigChange_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AboutInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHyperThreadScheduleInfo",lazy=True)(pname=(ns,"hyperThread"), aname="_hyperThread", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ServiceConsoleReservationInfo",lazy=True)(pname=(ns,"consoleReservation"), aname="_consoleReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMemoryReservationInfo",lazy=True)(pname=(ns,"virtualMachineReservation"), aname="_virtualMachineReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostStorageDeviceInfo",lazy=True)(pname=(ns,"storageDevice"), aname="_storageDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathStateInfo",lazy=True)(pname=(ns,"multipathState"), aname="_multipathState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFileSystemVolumeInfo",lazy=True)(pname=(ns,"fileSystemVolume"), aname="_fileSystemVolume", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVMotionInfo",lazy=True)(pname=(ns,"vmotion"), aname="_vmotion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicManagerInfo",lazy=True)(pname=(ns,"virtualNicManagerInfo"), aname="_virtualNicManagerInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetCapabilities",lazy=True)(pname=(ns,"capabilities"), aname="_capabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreSystemCapabilities",lazy=True)(pname=(ns,"datastoreCapabilities"), aname="_datastoreCapabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetOffloadCapabilities",lazy=True)(pname=(ns,"offloadCapabilities"), aname="_offloadCapabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostServiceInfo",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallInfo",lazy=True)(pname=(ns,"firewall"), aname="_firewall", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAutoStartManagerConfig",lazy=True)(pname=(ns,"autoStart"), aname="_autoStart", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiagnosticPartition",lazy=True)(pname=(ns,"activeDiagnosticPartition"), aname="_activeDiagnosticPartition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"optionDef"), aname="_optionDef", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePrincipal"), aname="_datastorePrincipal", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"localSwapDatastore"), aname="_localSwapDatastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"systemResources"), aname="_systemResources", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDateTimeInfo",lazy=True)(pname=(ns,"dateTimeInfo"), aname="_dateTimeInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFlagInfo",lazy=True)(pname=(ns,"flags"), aname="_flags", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"adminDisabled"), aname="_adminDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpmiInfo",lazy=True)(pname=(ns,"ipmi"), aname="_ipmi", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSslThumbprintInfo",lazy=True)(pname=(ns,"sslThumbprintInfo"), aname="_sslThumbprintInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPciPassthruInfo",lazy=True)(pname=(ns,"pciPassthruInfo"), aname="_pciPassthruInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConfigInfo_Def.__bases__: + bases = list(ns0.HostConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigManager_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigManager") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigManager_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"cpuScheduler"), aname="_cpuScheduler", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastoreSystem"), aname="_datastoreSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"memoryManager"), aname="_memoryManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"storageSystem"), aname="_storageSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"networkSystem"), aname="_networkSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmotionSystem"), aname="_vmotionSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"virtualNicManager"), aname="_virtualNicManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"serviceSystem"), aname="_serviceSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"firewallSystem"), aname="_firewallSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"advancedOption"), aname="_advancedOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"diagnosticSystem"), aname="_diagnosticSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"autoStartManager"), aname="_autoStartManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snmpSystem"), aname="_snmpSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dateTimeSystem"), aname="_dateTimeSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"patchManager"), aname="_patchManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"bootDeviceSystem"), aname="_bootDeviceSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"firmwareSystem"), aname="_firmwareSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"healthStatusSystem"), aname="_healthStatusSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pciPassthruSystem"), aname="_pciPassthruSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"licenseManager"), aname="_licenseManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"kernelModuleSystem"), aname="_kernelModuleSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConfigManager_Def.__bases__: + bases = list(ns0.HostConfigManager_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConfigManager_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigSpec_Def.schema + TClist = [GTD("urn:vim25","HostNasVolumeConfig",lazy=True)(pname=(ns,"nasDatastore"), aname="_nasDatastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkConfig",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicManagerNicTypeSelection",lazy=True)(pname=(ns,"nicTypeSelection"), aname="_nicTypeSelection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostServiceConfig",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallConfig",lazy=True)(pname=(ns,"firewall"), aname="_firewall", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePrincipal"), aname="_datastorePrincipal", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePrincipalPasswd"), aname="_datastorePrincipalPasswd", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDateTimeConfig",lazy=True)(pname=(ns,"datetime"), aname="_datetime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostStorageDeviceInfo",lazy=True)(pname=(ns,"storageDevice"), aname="_storageDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostLicenseSpec",lazy=True)(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSecuritySpec",lazy=True)(pname=(ns,"security"), aname="_security", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"userAccount"), aname="_userAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"usergroupAccount"), aname="_usergroupAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMemorySpec",lazy=True)(pname=(ns,"memory"), aname="_memory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConfigSpec_Def.__bases__: + bases = list(ns0.HostConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConnectInfoNetworkInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConnectInfoNetworkInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConnectInfoNetworkInfo_Def.schema + TClist = [GTD("urn:vim25","NetworkSummary",lazy=True)(pname=(ns,"summary"), aname="_summary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConnectInfoNetworkInfo_Def.__bases__: + bases = list(ns0.HostConnectInfoNetworkInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConnectInfoNetworkInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostConnectInfoNetworkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostConnectInfoNetworkInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostConnectInfoNetworkInfo_Def.schema + TClist = [GTD("urn:vim25","HostConnectInfoNetworkInfo",lazy=True)(pname=(ns,"HostConnectInfoNetworkInfo"), aname="_HostConnectInfoNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostConnectInfoNetworkInfo = [] + return + Holder.__name__ = "ArrayOfHostConnectInfoNetworkInfo_Holder" + self.pyclass = Holder + + class HostNewNetworkConnectInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNewNetworkConnectInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNewNetworkConnectInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostConnectInfoNetworkInfo_Def not in ns0.HostNewNetworkConnectInfo_Def.__bases__: + bases = list(ns0.HostNewNetworkConnectInfo_Def.__bases__) + bases.insert(0, ns0.HostConnectInfoNetworkInfo_Def) + ns0.HostNewNetworkConnectInfo_Def.__bases__ = tuple(bases) + + ns0.HostConnectInfoNetworkInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDatastoreConnectInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDatastoreConnectInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDatastoreConnectInfo_Def.schema + TClist = [GTD("urn:vim25","DatastoreSummary",lazy=True)(pname=(ns,"summary"), aname="_summary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDatastoreConnectInfo_Def.__bases__: + bases = list(ns0.HostDatastoreConnectInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDatastoreConnectInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDatastoreConnectInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDatastoreConnectInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDatastoreConnectInfo_Def.schema + TClist = [GTD("urn:vim25","HostDatastoreConnectInfo",lazy=True)(pname=(ns,"HostDatastoreConnectInfo"), aname="_HostDatastoreConnectInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDatastoreConnectInfo = [] + return + Holder.__name__ = "ArrayOfHostDatastoreConnectInfo_Holder" + self.pyclass = Holder + + class HostDatastoreExistsConnectInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDatastoreExistsConnectInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDatastoreExistsConnectInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"newDatastoreName"), aname="_newDatastoreName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDatastoreConnectInfo_Def not in ns0.HostDatastoreExistsConnectInfo_Def.__bases__: + bases = list(ns0.HostDatastoreExistsConnectInfo_Def.__bases__) + bases.insert(0, ns0.HostDatastoreConnectInfo_Def) + ns0.HostDatastoreExistsConnectInfo_Def.__bases__ = tuple(bases) + + ns0.HostDatastoreConnectInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDatastoreNameConflictConnectInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDatastoreNameConflictConnectInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDatastoreNameConflictConnectInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"newDatastoreName"), aname="_newDatastoreName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDatastoreConnectInfo_Def not in ns0.HostDatastoreNameConflictConnectInfo_Def.__bases__: + bases = list(ns0.HostDatastoreNameConflictConnectInfo_Def.__bases__) + bases.insert(0, ns0.HostDatastoreConnectInfo_Def) + ns0.HostDatastoreNameConflictConnectInfo_Def.__bases__ = tuple(bases) + + ns0.HostDatastoreConnectInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostLicenseConnectInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostLicenseConnectInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostLicenseConnectInfo_Def.schema + TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"license"), aname="_license", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseManagerEvaluationInfo",lazy=True)(pname=(ns,"evaluation"), aname="_evaluation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostLicenseConnectInfo_Def.__bases__: + bases = list(ns0.HostLicenseConnectInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostLicenseConnectInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConnectInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConnectInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConnectInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"serverIp"), aname="_serverIp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostListSummary",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSummary",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vimAccountNameRequired"), aname="_vimAccountNameRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"clusterSupported"), aname="_clusterSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectInfoNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreConnectInfo",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostLicenseConnectInfo",lazy=True)(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConnectInfo_Def.__bases__: + bases = list(ns0.HostConnectInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConnectInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConnectSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConnectSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConnectSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmFolder"), aname="_vmFolder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vimAccountName"), aname="_vimAccountName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vimAccountPassword"), aname="_vimAccountPassword", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"managementIp"), aname="_managementIp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConnectSpec_Def.__bases__: + bases = list(ns0.HostConnectSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConnectSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCpuIdInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCpuIdInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCpuIdInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eax"), aname="_eax", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ebx"), aname="_ebx", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ecx"), aname="_ecx", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"edx"), aname="_edx", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostCpuIdInfo_Def.__bases__: + bases = list(ns0.HostCpuIdInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostCpuIdInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostCpuIdInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostCpuIdInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostCpuIdInfo_Def.schema + TClist = [GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"HostCpuIdInfo"), aname="_HostCpuIdInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostCpuIdInfo = [] + return + Holder.__name__ = "ArrayOfHostCpuIdInfo_Holder" + self.pyclass = Holder + + class HostHyperThreadScheduleInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostHyperThreadScheduleInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostHyperThreadScheduleInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"active"), aname="_active", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostHyperThreadScheduleInfo_Def.__bases__: + bases = list(ns0.HostHyperThreadScheduleInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostHyperThreadScheduleInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class EnableHyperThreadingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EnableHyperThreadingRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.EnableHyperThreadingRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "EnableHyperThreadingRequestType_Holder" + self.pyclass = Holder + + class DisableHyperThreadingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DisableHyperThreadingRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DisableHyperThreadingRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DisableHyperThreadingRequestType_Holder" + self.pyclass = Holder + + class FileQueryFlags_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileQueryFlags") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileQueryFlags_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"fileType"), aname="_fileType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fileSize"), aname="_fileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"modification"), aname="_modification", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fileOwner"), aname="_fileOwner", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.FileQueryFlags_Def.__bases__: + bases = list(ns0.FileQueryFlags_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.FileQueryFlags_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"fileSize"), aname="_fileSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"modification"), aname="_modification", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"owner"), aname="_owner", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.FileInfo_Def.__bases__: + bases = list(ns0.FileInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.FileInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfFileInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfFileInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfFileInfo_Def.schema + TClist = [GTD("urn:vim25","FileInfo",lazy=True)(pname=(ns,"FileInfo"), aname="_FileInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._FileInfo = [] + return + Holder.__name__ = "ArrayOfFileInfo_Holder" + self.pyclass = Holder + + class FileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.FileQuery_Def.__bases__: + bases = list(ns0.FileQuery_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.FileQuery_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfFileQuery_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfFileQuery") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfFileQuery_Def.schema + TClist = [GTD("urn:vim25","FileQuery",lazy=True)(pname=(ns,"FileQuery"), aname="_FileQuery", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._FileQuery = [] + return + Holder.__name__ = "ArrayOfFileQuery_Holder" + self.pyclass = Holder + + class VmConfigFileQueryFilter_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigFileQueryFilter") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigFileQueryFilter_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"matchConfigVersion"), aname="_matchConfigVersion", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmConfigFileQueryFilter_Def.__bases__: + bases = list(ns0.VmConfigFileQueryFilter_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmConfigFileQueryFilter_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigFileQueryFlags_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigFileQueryFlags") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigFileQueryFlags_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmConfigFileQueryFlags_Def.__bases__: + bases = list(ns0.VmConfigFileQueryFlags_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmConfigFileQueryFlags_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigFileQuery_Def.schema + TClist = [GTD("urn:vim25","VmConfigFileQueryFilter",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmConfigFileQueryFlags",lazy=True)(pname=(ns,"details"), aname="_details", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.VmConfigFileQuery_Def.__bases__: + bases = list(ns0.VmConfigFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.VmConfigFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TemplateConfigFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TemplateConfigFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TemplateConfigFileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFileQuery_Def not in ns0.TemplateConfigFileQuery_Def.__bases__: + bases = list(ns0.TemplateConfigFileQuery_Def.__bases__) + bases.insert(0, ns0.VmConfigFileQuery_Def) + ns0.TemplateConfigFileQuery_Def.__bases__ = tuple(bases) + + ns0.VmConfigFileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDiskFileQueryFilter_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDiskFileQueryFilter") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDiskFileQueryFilter_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskType"), aname="_diskType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"matchHardwareVersion"), aname="_matchHardwareVersion", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thin"), aname="_thin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmDiskFileQueryFilter_Def.__bases__: + bases = list(ns0.VmDiskFileQueryFilter_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmDiskFileQueryFilter_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDiskFileQueryFlags_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDiskFileQueryFlags") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDiskFileQueryFlags_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"diskType"), aname="_diskType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"capacityKb"), aname="_capacityKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hardwareVersion"), aname="_hardwareVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"diskExtents"), aname="_diskExtents", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thin"), aname="_thin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmDiskFileQueryFlags_Def.__bases__: + bases = list(ns0.VmDiskFileQueryFlags_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmDiskFileQueryFlags_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDiskFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDiskFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDiskFileQuery_Def.schema + TClist = [GTD("urn:vim25","VmDiskFileQueryFilter",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmDiskFileQueryFlags",lazy=True)(pname=(ns,"details"), aname="_details", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.VmDiskFileQuery_Def.__bases__: + bases = list(ns0.VmDiskFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.VmDiskFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FolderFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FolderFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FolderFileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.FolderFileQuery_Def.__bases__: + bases = list(ns0.FolderFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.FolderFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSnapshotFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSnapshotFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSnapshotFileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.VmSnapshotFileQuery_Def.__bases__: + bases = list(ns0.VmSnapshotFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.VmSnapshotFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IsoImageFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IsoImageFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IsoImageFileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.IsoImageFileQuery_Def.__bases__: + bases = list(ns0.IsoImageFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.IsoImageFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FloppyImageFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FloppyImageFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FloppyImageFileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.FloppyImageFileQuery_Def.__bases__: + bases = list(ns0.FloppyImageFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.FloppyImageFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmNvramFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmNvramFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmNvramFileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.VmNvramFileQuery_Def.__bases__: + bases = list(ns0.VmNvramFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.VmNvramFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmLogFileQuery_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmLogFileQuery") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmLogFileQuery_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileQuery_Def not in ns0.VmLogFileQuery_Def.__bases__: + bases = list(ns0.VmLogFileQuery_Def.__bases__) + bases.insert(0, ns0.FileQuery_Def) + ns0.VmLogFileQuery_Def.__bases__ = tuple(bases) + + ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigFileInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.VmConfigFileInfo_Def.__bases__: + bases = list(ns0.VmConfigFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.VmConfigFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class TemplateConfigFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TemplateConfigFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TemplateConfigFileInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigFileInfo_Def not in ns0.TemplateConfigFileInfo_Def.__bases__: + bases = list(ns0.TemplateConfigFileInfo_Def.__bases__) + bases.insert(0, ns0.VmConfigFileInfo_Def) + ns0.TemplateConfigFileInfo_Def.__bases__ = tuple(bases) + + ns0.VmConfigFileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmDiskFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmDiskFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmDiskFileInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskType"), aname="_diskType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacityKb"), aname="_capacityKb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hardwareVersion"), aname="_hardwareVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskExtents"), aname="_diskExtents", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thin"), aname="_thin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.VmDiskFileInfo_Def.__bases__: + bases = list(ns0.VmDiskFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.VmDiskFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FolderFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FolderFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FolderFileInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.FolderFileInfo_Def.__bases__: + bases = list(ns0.FolderFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.FolderFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmSnapshotFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmSnapshotFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmSnapshotFileInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.VmSnapshotFileInfo_Def.__bases__: + bases = list(ns0.VmSnapshotFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.VmSnapshotFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IsoImageFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IsoImageFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IsoImageFileInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.IsoImageFileInfo_Def.__bases__: + bases = list(ns0.IsoImageFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.IsoImageFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FloppyImageFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FloppyImageFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FloppyImageFileInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.FloppyImageFileInfo_Def.__bases__: + bases = list(ns0.FloppyImageFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.FloppyImageFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmNvramFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmNvramFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmNvramFileInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.VmNvramFileInfo_Def.__bases__: + bases = list(ns0.VmNvramFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.VmNvramFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmLogFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmLogFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmLogFileInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FileInfo_Def not in ns0.VmLogFileInfo_Def.__bases__: + bases = list(ns0.VmLogFileInfo_Def.__bases__) + bases.insert(0, ns0.FileInfo_Def) + ns0.VmLogFileInfo_Def.__bases__ = tuple(bases) + + ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDatastoreBrowserSearchSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDatastoreBrowserSearchSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDatastoreBrowserSearchSpec_Def.schema + TClist = [GTD("urn:vim25","FileQuery",lazy=True)(pname=(ns,"query"), aname="_query", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FileQueryFlags",lazy=True)(pname=(ns,"details"), aname="_details", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"searchCaseInsensitive"), aname="_searchCaseInsensitive", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"matchPattern"), aname="_matchPattern", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sortFoldersFirst"), aname="_sortFoldersFirst", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDatastoreBrowserSearchSpec_Def.__bases__: + bases = list(ns0.HostDatastoreBrowserSearchSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDatastoreBrowserSearchSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDatastoreBrowserSearchResults_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDatastoreBrowserSearchResults") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDatastoreBrowserSearchResults_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"folderPath"), aname="_folderPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FileInfo",lazy=True)(pname=(ns,"file"), aname="_file", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDatastoreBrowserSearchResults_Def.__bases__: + bases = list(ns0.HostDatastoreBrowserSearchResults_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDatastoreBrowserSearchResults_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDatastoreBrowserSearchResults_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDatastoreBrowserSearchResults") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDatastoreBrowserSearchResults_Def.schema + TClist = [GTD("urn:vim25","HostDatastoreBrowserSearchResults",lazy=True)(pname=(ns,"HostDatastoreBrowserSearchResults"), aname="_HostDatastoreBrowserSearchResults", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDatastoreBrowserSearchResults = [] + return + Holder.__name__ = "ArrayOfHostDatastoreBrowserSearchResults_Holder" + self.pyclass = Holder + + class SearchDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SearchDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SearchDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreBrowserSearchSpec",lazy=True)(pname=(ns,"searchSpec"), aname="_searchSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastorePath = None + self._searchSpec = None + return + Holder.__name__ = "SearchDatastoreRequestType_Holder" + self.pyclass = Holder + + class SearchDatastoreSubFoldersRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SearchDatastoreSubFoldersRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SearchDatastoreSubFoldersRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreBrowserSearchSpec",lazy=True)(pname=(ns,"searchSpec"), aname="_searchSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastorePath = None + self._searchSpec = None + return + Holder.__name__ = "SearchDatastoreSubFoldersRequestType_Holder" + self.pyclass = Holder + + class DeleteFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DeleteFileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DeleteFileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastorePath = None + return + Holder.__name__ = "DeleteFileRequestType_Holder" + self.pyclass = Holder + + class HostDatastoreSystemCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDatastoreSystemCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDatastoreSystemCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"nfsMountCreationRequired"), aname="_nfsMountCreationRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"nfsMountCreationSupported"), aname="_nfsMountCreationSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"localDatastoreSupported"), aname="_localDatastoreSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmfsExtentExpansionSupported"), aname="_vmfsExtentExpansionSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDatastoreSystemCapabilities_Def.__bases__: + bases = list(ns0.HostDatastoreSystemCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDatastoreSystemCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateLocalSwapDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateLocalSwapDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateLocalSwapDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastore = None + return + Holder.__name__ = "UpdateLocalSwapDatastoreRequestType_Holder" + self.pyclass = Holder + + class QueryAvailableDisksForVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryAvailableDisksForVmfsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryAvailableDisksForVmfsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastore = None + return + Holder.__name__ = "QueryAvailableDisksForVmfsRequestType_Holder" + self.pyclass = Holder + + class QueryVmfsDatastoreCreateOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVmfsDatastoreCreateOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._devicePath = None + return + Holder.__name__ = "QueryVmfsDatastoreCreateOptionsRequestType_Holder" + self.pyclass = Holder + + class CreateVmfsDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateVmfsDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateVmfsDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "CreateVmfsDatastoreRequestType_Holder" + self.pyclass = Holder + + class QueryVmfsDatastoreExtendOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVmfsDatastoreExtendOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suppressExpandCandidates"), aname="_suppressExpandCandidates", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastore = None + self._devicePath = None + self._suppressExpandCandidates = None + return + Holder.__name__ = "QueryVmfsDatastoreExtendOptionsRequestType_Holder" + self.pyclass = Holder + + class QueryVmfsDatastoreExpandOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVmfsDatastoreExpandOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastore = None + return + Holder.__name__ = "QueryVmfsDatastoreExpandOptionsRequestType_Holder" + self.pyclass = Holder + + class ExtendVmfsDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExtendVmfsDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExtendVmfsDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreExtendSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastore = None + self._spec = None + return + Holder.__name__ = "ExtendVmfsDatastoreRequestType_Holder" + self.pyclass = Holder + + class ExpandVmfsDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExpandVmfsDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExpandVmfsDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreExpandSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastore = None + self._spec = None + return + Holder.__name__ = "ExpandVmfsDatastoreRequestType_Holder" + self.pyclass = Holder + + class CreateNasDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateNasDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateNasDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNasVolumeSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "CreateNasDatastoreRequestType_Holder" + self.pyclass = Holder + + class CreateLocalDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateLocalDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateLocalDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._path = None + return + Holder.__name__ = "CreateLocalDatastoreRequestType_Holder" + self.pyclass = Holder + + class RemoveDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveDatastoreRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveDatastoreRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._datastore = None + return + Holder.__name__ = "RemoveDatastoreRequestType_Holder" + self.pyclass = Holder + + class ConfigureDatastorePrincipalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ConfigureDatastorePrincipalRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ConfigureDatastorePrincipalRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._userName = None + self._password = None + return + Holder.__name__ = "ConfigureDatastorePrincipalRequestType_Holder" + self.pyclass = Holder + + class QueryUnresolvedVmfsVolumesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryUnresolvedVmfsVolumesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryUnresolvedVmfsVolumesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryUnresolvedVmfsVolumesRequestType_Holder" + self.pyclass = Holder + + class ResignatureUnresolvedVmfsVolumeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResignatureUnresolvedVmfsVolumeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostUnresolvedVmfsResignatureSpec",lazy=True)(pname=(ns,"resolutionSpec"), aname="_resolutionSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._resolutionSpec = None + return + Holder.__name__ = "ResignatureUnresolvedVmfsVolumeRequestType_Holder" + self.pyclass = Holder + + class VmfsDatastoreInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreInfo_Def.schema + TClist = [GTD("urn:vim25","HostVmfsVolume",lazy=True)(pname=(ns,"vmfs"), aname="_vmfs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreInfo_Def not in ns0.VmfsDatastoreInfo_Def.__bases__: + bases = list(ns0.VmfsDatastoreInfo_Def.__bases__) + bases.insert(0, ns0.DatastoreInfo_Def) + ns0.VmfsDatastoreInfo_Def.__bases__ = tuple(bases) + + ns0.DatastoreInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NasDatastoreInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NasDatastoreInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NasDatastoreInfo_Def.schema + TClist = [GTD("urn:vim25","HostNasVolume",lazy=True)(pname=(ns,"nas"), aname="_nas", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreInfo_Def not in ns0.NasDatastoreInfo_Def.__bases__: + bases = list(ns0.NasDatastoreInfo_Def.__bases__) + bases.insert(0, ns0.DatastoreInfo_Def) + ns0.NasDatastoreInfo_Def.__bases__ = tuple(bases) + + ns0.DatastoreInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LocalDatastoreInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LocalDatastoreInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LocalDatastoreInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DatastoreInfo_Def not in ns0.LocalDatastoreInfo_Def.__bases__: + bases = list(ns0.LocalDatastoreInfo_Def.__bases__) + bases.insert(0, ns0.DatastoreInfo_Def) + ns0.LocalDatastoreInfo_Def.__bases__ = tuple(bases) + + ns0.DatastoreInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskUuid"), aname="_diskUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmfsDatastoreSpec_Def.__bases__: + bases = list(ns0.VmfsDatastoreSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmfsDatastoreSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreCreateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreCreateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreCreateSpec_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVmfsSpec",lazy=True)(pname=(ns,"vmfs"), aname="_vmfs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsDatastoreSpec_Def not in ns0.VmfsDatastoreCreateSpec_Def.__bases__: + bases = list(ns0.VmfsDatastoreCreateSpec_Def.__bases__) + bases.insert(0, ns0.VmfsDatastoreSpec_Def) + ns0.VmfsDatastoreCreateSpec_Def.__bases__ = tuple(bases) + + ns0.VmfsDatastoreSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreExtendSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreExtendSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreExtendSpec_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsDatastoreSpec_Def not in ns0.VmfsDatastoreExtendSpec_Def.__bases__: + bases = list(ns0.VmfsDatastoreExtendSpec_Def.__bases__) + bases.insert(0, ns0.VmfsDatastoreSpec_Def) + ns0.VmfsDatastoreExtendSpec_Def.__bases__ = tuple(bases) + + ns0.VmfsDatastoreSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreExpandSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreExpandSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreExpandSpec_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsDatastoreSpec_Def not in ns0.VmfsDatastoreExpandSpec_Def.__bases__: + bases = list(ns0.VmfsDatastoreExpandSpec_Def.__bases__) + bases.insert(0, ns0.VmfsDatastoreSpec_Def) + ns0.VmfsDatastoreExpandSpec_Def.__bases__ = tuple(bases) + + ns0.VmfsDatastoreSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreBaseOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreBaseOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreBaseOption_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmfsDatastoreBaseOption_Def.__bases__: + bases = list(ns0.VmfsDatastoreBaseOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmfsDatastoreBaseOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreSingleExtentOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreSingleExtentOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreSingleExtentOption_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"vmfsExtent"), aname="_vmfsExtent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsDatastoreBaseOption_Def not in ns0.VmfsDatastoreSingleExtentOption_Def.__bases__: + bases = list(ns0.VmfsDatastoreSingleExtentOption_Def.__bases__) + bases.insert(0, ns0.VmfsDatastoreBaseOption_Def) + ns0.VmfsDatastoreSingleExtentOption_Def.__bases__ = tuple(bases) + + ns0.VmfsDatastoreBaseOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreAllExtentOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreAllExtentOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreAllExtentOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsDatastoreSingleExtentOption_Def not in ns0.VmfsDatastoreAllExtentOption_Def.__bases__: + bases = list(ns0.VmfsDatastoreAllExtentOption_Def.__bases__) + bases.insert(0, ns0.VmfsDatastoreSingleExtentOption_Def) + ns0.VmfsDatastoreAllExtentOption_Def.__bases__ = tuple(bases) + + ns0.VmfsDatastoreSingleExtentOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreMultipleExtentOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreMultipleExtentOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreMultipleExtentOption_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"vmfsExtent"), aname="_vmfsExtent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmfsDatastoreBaseOption_Def not in ns0.VmfsDatastoreMultipleExtentOption_Def.__bases__: + bases = list(ns0.VmfsDatastoreMultipleExtentOption_Def.__bases__) + bases.insert(0, ns0.VmfsDatastoreBaseOption_Def) + ns0.VmfsDatastoreMultipleExtentOption_Def.__bases__ = tuple(bases) + + ns0.VmfsDatastoreBaseOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmfsDatastoreOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmfsDatastoreOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmfsDatastoreOption_Def.schema + TClist = [GTD("urn:vim25","VmfsDatastoreBaseOption",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmfsDatastoreOption_Def.__bases__: + bases = list(ns0.VmfsDatastoreOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmfsDatastoreOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVmfsDatastoreOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVmfsDatastoreOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVmfsDatastoreOption_Def.schema + TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"VmfsDatastoreOption"), aname="_VmfsDatastoreOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VmfsDatastoreOption = [] + return + Holder.__name__ = "ArrayOfVmfsDatastoreOption_Holder" + self.pyclass = Holder + + class HostDateTimeConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDateTimeConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDateTimeConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNtpConfig",lazy=True)(pname=(ns,"ntpConfig"), aname="_ntpConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDateTimeConfig_Def.__bases__: + bases = list(ns0.HostDateTimeConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDateTimeConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDateTimeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDateTimeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDateTimeInfo_Def.schema + TClist = [GTD("urn:vim25","HostDateTimeSystemTimeZone",lazy=True)(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNtpConfig",lazy=True)(pname=(ns,"ntpConfig"), aname="_ntpConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDateTimeInfo_Def.__bases__: + bases = list(ns0.HostDateTimeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDateTimeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDateTimeSystemTimeZone_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDateTimeSystemTimeZone") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDateTimeSystemTimeZone_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"gmtOffset"), aname="_gmtOffset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDateTimeSystemTimeZone_Def.__bases__: + bases = list(ns0.HostDateTimeSystemTimeZone_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDateTimeSystemTimeZone_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDateTimeSystemTimeZone_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDateTimeSystemTimeZone") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDateTimeSystemTimeZone_Def.schema + TClist = [GTD("urn:vim25","HostDateTimeSystemTimeZone",lazy=True)(pname=(ns,"HostDateTimeSystemTimeZone"), aname="_HostDateTimeSystemTimeZone", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDateTimeSystemTimeZone = [] + return + Holder.__name__ = "ArrayOfHostDateTimeSystemTimeZone_Holder" + self.pyclass = Holder + + class UpdateDateTimeConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateDateTimeConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateDateTimeConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDateTimeConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + return + Holder.__name__ = "UpdateDateTimeConfigRequestType_Holder" + self.pyclass = Holder + + class QueryAvailableTimeZonesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryAvailableTimeZonesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryAvailableTimeZonesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryAvailableTimeZonesRequestType_Holder" + self.pyclass = Holder + + class QueryDateTimeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryDateTimeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryDateTimeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryDateTimeRequestType_Holder" + self.pyclass = Holder + + class UpdateDateTimeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateDateTimeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateDateTimeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"dateTime"), aname="_dateTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._dateTime = None + return + Holder.__name__ = "UpdateDateTimeRequestType_Holder" + self.pyclass = Holder + + class RefreshDateTimeSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshDateTimeSystemRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshDateTimeSystemRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshDateTimeSystemRequestType_Holder" + self.pyclass = Holder + + class HostDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDevice_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceType"), aname="_deviceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDevice_Def.__bases__: + bases = list(ns0.HostDevice_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDevice_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDhcpServiceSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDhcpServiceSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDhcpServiceSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"virtualSwitch"), aname="_virtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultLeaseDuration"), aname="_defaultLeaseDuration", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"leaseBeginIp"), aname="_leaseBeginIp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"leaseEndIp"), aname="_leaseEndIp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxLeaseDuration"), aname="_maxLeaseDuration", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unlimitedLease"), aname="_unlimitedLease", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipSubnetAddr"), aname="_ipSubnetAddr", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipSubnetMask"), aname="_ipSubnetMask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDhcpServiceSpec_Def.__bases__: + bases = list(ns0.HostDhcpServiceSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDhcpServiceSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDhcpServiceConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDhcpServiceConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDhcpServiceConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDhcpServiceConfig_Def.__bases__: + bases = list(ns0.HostDhcpServiceConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDhcpServiceConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDhcpServiceConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDhcpServiceConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDhcpServiceConfig_Def.schema + TClist = [GTD("urn:vim25","HostDhcpServiceConfig",lazy=True)(pname=(ns,"HostDhcpServiceConfig"), aname="_HostDhcpServiceConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDhcpServiceConfig = [] + return + Holder.__name__ = "ArrayOfHostDhcpServiceConfig_Holder" + self.pyclass = Holder + + class HostDhcpService_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDhcpService") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDhcpService_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDhcpService_Def.__bases__: + bases = list(ns0.HostDhcpService_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDhcpService_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDhcpService_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDhcpService") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDhcpService_Def.schema + TClist = [GTD("urn:vim25","HostDhcpService",lazy=True)(pname=(ns,"HostDhcpService"), aname="_HostDhcpService", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDhcpService = [] + return + Holder.__name__ = "ArrayOfHostDhcpService_Holder" + self.pyclass = Holder + + class QueryAvailablePartitionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryAvailablePartitionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryAvailablePartitionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryAvailablePartitionRequestType_Holder" + self.pyclass = Holder + + class SelectActivePartitionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SelectActivePartitionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SelectActivePartitionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._partition = None + return + Holder.__name__ = "SelectActivePartitionRequestType_Holder" + self.pyclass = Holder + + class QueryPartitionCreateOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPartitionCreateOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPartitionCreateOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._storageType = None + self._diagnosticType = None + return + Holder.__name__ = "QueryPartitionCreateOptionsRequestType_Holder" + self.pyclass = Holder + + class QueryPartitionCreateDescRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPartitionCreateDescRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPartitionCreateDescRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskUuid"), aname="_diskUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._diskUuid = None + self._diagnosticType = None + return + Holder.__name__ = "QueryPartitionCreateDescRequestType_Holder" + self.pyclass = Holder + + class CreateDiagnosticPartitionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateDiagnosticPartitionRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateDiagnosticPartitionRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiagnosticPartitionCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "CreateDiagnosticPartitionRequestType_Holder" + self.pyclass = Holder + + class DiagnosticPartitionStorageType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DiagnosticPartitionStorageType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class DiagnosticPartitionType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DiagnosticPartitionType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostDiagnosticPartitionCreateOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiagnosticPartitionCreateOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiagnosticPartitionCreateOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiagnosticPartitionCreateOption_Def.__bases__: + bases = list(ns0.HostDiagnosticPartitionCreateOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiagnosticPartitionCreateOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDiagnosticPartitionCreateOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDiagnosticPartitionCreateOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDiagnosticPartitionCreateOption_Def.schema + TClist = [GTD("urn:vim25","HostDiagnosticPartitionCreateOption",lazy=True)(pname=(ns,"HostDiagnosticPartitionCreateOption"), aname="_HostDiagnosticPartitionCreateOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDiagnosticPartitionCreateOption = [] + return + Holder.__name__ = "ArrayOfHostDiagnosticPartitionCreateOption_Holder" + self.pyclass = Holder + + class HostDiagnosticPartitionCreateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiagnosticPartitionCreateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiagnosticPartitionCreateSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"active"), aname="_active", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiagnosticPartitionCreateSpec_Def.__bases__: + bases = list(ns0.HostDiagnosticPartitionCreateSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiagnosticPartitionCreateSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiagnosticPartitionCreateDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiagnosticPartitionCreateDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiagnosticPartitionCreateDescription_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskUuid"), aname="_diskUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiagnosticPartitionCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiagnosticPartitionCreateDescription_Def.__bases__: + bases = list(ns0.HostDiagnosticPartitionCreateDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiagnosticPartitionCreateDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiagnosticPartition_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiagnosticPartition") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiagnosticPartition_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"slots"), aname="_slots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiagnosticPartition_Def.__bases__: + bases = list(ns0.HostDiagnosticPartition_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiagnosticPartition_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDiagnosticPartition_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDiagnosticPartition") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDiagnosticPartition_Def.schema + TClist = [GTD("urn:vim25","HostDiagnosticPartition",lazy=True)(pname=(ns,"HostDiagnosticPartition"), aname="_HostDiagnosticPartition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDiagnosticPartition = [] + return + Holder.__name__ = "ArrayOfHostDiagnosticPartition_Holder" + self.pyclass = Holder + + class HostDiskDimensionsChs_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskDimensionsChs") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskDimensionsChs_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"cylinder"), aname="_cylinder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"head"), aname="_head", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"sector"), aname="_sector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskDimensionsChs_Def.__bases__: + bases = list(ns0.HostDiskDimensionsChs_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskDimensionsChs_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiskDimensionsLba_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskDimensionsLba") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskDimensionsLba_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"blockSize"), aname="_blockSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"block"), aname="_block", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskDimensionsLba_Def.__bases__: + bases = list(ns0.HostDiskDimensionsLba_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskDimensionsLba_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiskDimensions_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskDimensions") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskDimensions_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskDimensions_Def.__bases__: + bases = list(ns0.HostDiskDimensions_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskDimensions_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiskPartitionInfoType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostDiskPartitionInfoType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostDiskPartitionAttributes_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskPartitionAttributes") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskPartitionAttributes_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"startSector"), aname="_startSector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"endSector"), aname="_endSector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"logical"), aname="_logical", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"attributes"), aname="_attributes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskPartitionAttributes_Def.__bases__: + bases = list(ns0.HostDiskPartitionAttributes_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskPartitionAttributes_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDiskPartitionAttributes_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDiskPartitionAttributes") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDiskPartitionAttributes_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionAttributes",lazy=True)(pname=(ns,"HostDiskPartitionAttributes"), aname="_HostDiskPartitionAttributes", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDiskPartitionAttributes = [] + return + Holder.__name__ = "ArrayOfHostDiskPartitionAttributes_Holder" + self.pyclass = Holder + + class HostDiskPartitionBlockRange_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskPartitionBlockRange") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskPartitionBlockRange_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"start"), aname="_start", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"end"), aname="_end", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskPartitionBlockRange_Def.__bases__: + bases = list(ns0.HostDiskPartitionBlockRange_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskPartitionBlockRange_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDiskPartitionBlockRange_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDiskPartitionBlockRange") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDiskPartitionBlockRange_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"HostDiskPartitionBlockRange"), aname="_HostDiskPartitionBlockRange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDiskPartitionBlockRange = [] + return + Holder.__name__ = "ArrayOfHostDiskPartitionBlockRange_Holder" + self.pyclass = Holder + + class HostDiskPartitionSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskPartitionSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskPartitionSpec_Def.schema + TClist = [GTD("urn:vim25","HostDiskDimensionsChs",lazy=True)(pname=(ns,"chs"), aname="_chs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"totalSectors"), aname="_totalSectors", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionAttributes",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskPartitionSpec_Def.__bases__: + bases = list(ns0.HostDiskPartitionSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskPartitionSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiskPartitionLayout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskPartitionLayout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskPartitionLayout_Def.schema + TClist = [GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"total"), aname="_total", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskPartitionLayout_Def.__bases__: + bases = list(ns0.HostDiskPartitionLayout_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskPartitionLayout_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiskPartitionInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskPartitionInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskPartitionInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskPartitionInfo_Def.__bases__: + bases = list(ns0.HostDiskPartitionInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskPartitionInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDiskPartitionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDiskPartitionInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDiskPartitionInfo_Def.schema + TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"HostDiskPartitionInfo"), aname="_HostDiskPartitionInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDiskPartitionInfo = [] + return + Holder.__name__ = "ArrayOfHostDiskPartitionInfo_Holder" + self.pyclass = Holder + + class HostDnsConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDnsConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDnsConfig_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"virtualNicDevice"), aname="_virtualNicDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domainName"), aname="_domainName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"searchDomain"), aname="_searchDomain", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDnsConfig_Def.__bases__: + bases = list(ns0.HostDnsConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDnsConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDnsConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDnsConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDnsConfigSpec_Def.schema + TClist = [GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"virtualNicConnection"), aname="_virtualNicConnection", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDnsConfig_Def not in ns0.HostDnsConfigSpec_Def.__bases__: + bases = list(ns0.HostDnsConfigSpec_Def.__bases__) + bases.insert(0, ns0.HostDnsConfig_Def) + ns0.HostDnsConfigSpec_Def.__bases__ = tuple(bases) + + ns0.HostDnsConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ModeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ModeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ModeInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"browse"), aname="_browse", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"read"), aname="_read", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"modify"), aname="_modify", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"use"), aname="_use", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"admin"), aname="_admin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"full"), aname="_full", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ModeInfo_Def.__bases__: + bases = list(ns0.ModeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ModeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFileAccess_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFileAccess") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFileAccess_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"who"), aname="_who", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"what"), aname="_what", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFileAccess_Def.__bases__: + bases = list(ns0.HostFileAccess_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFileAccess_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFileSystemVolumeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFileSystemVolumeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFileSystemVolumeInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"volumeTypeList"), aname="_volumeTypeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFileSystemMountInfo",lazy=True)(pname=(ns,"mountInfo"), aname="_mountInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFileSystemVolumeInfo_Def.__bases__: + bases = list(ns0.HostFileSystemVolumeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFileSystemVolumeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFileSystemMountInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFileSystemMountInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFileSystemMountInfo_Def.schema + TClist = [GTD("urn:vim25","HostMountInfo",lazy=True)(pname=(ns,"mountInfo"), aname="_mountInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFileSystemVolume",lazy=True)(pname=(ns,"volume"), aname="_volume", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFileSystemMountInfo_Def.__bases__: + bases = list(ns0.HostFileSystemMountInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFileSystemMountInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostFileSystemMountInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostFileSystemMountInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostFileSystemMountInfo_Def.schema + TClist = [GTD("urn:vim25","HostFileSystemMountInfo",lazy=True)(pname=(ns,"HostFileSystemMountInfo"), aname="_HostFileSystemMountInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostFileSystemMountInfo = [] + return + Holder.__name__ = "ArrayOfHostFileSystemMountInfo_Holder" + self.pyclass = Holder + + class HostFileSystemVolume_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFileSystemVolume") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFileSystemVolume_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFileSystemVolume_Def.__bases__: + bases = list(ns0.HostFileSystemVolume_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFileSystemVolume_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNasVolumeSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNasVolumeSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNasVolumeSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localPath"), aname="_localPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"accessMode"), aname="_accessMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNasVolumeSpec_Def.__bases__: + bases = list(ns0.HostNasVolumeSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNasVolumeSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNasVolumeConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNasVolumeConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNasVolumeConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNasVolumeSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNasVolumeConfig_Def.__bases__: + bases = list(ns0.HostNasVolumeConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNasVolumeConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostNasVolumeConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostNasVolumeConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostNasVolumeConfig_Def.schema + TClist = [GTD("urn:vim25","HostNasVolumeConfig",lazy=True)(pname=(ns,"HostNasVolumeConfig"), aname="_HostNasVolumeConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostNasVolumeConfig = [] + return + Holder.__name__ = "ArrayOfHostNasVolumeConfig_Holder" + self.pyclass = Holder + + class HostNasVolume_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNasVolume") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNasVolume_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostFileSystemVolume_Def not in ns0.HostNasVolume_Def.__bases__: + bases = list(ns0.HostNasVolume_Def.__bases__) + bases.insert(0, ns0.HostFileSystemVolume_Def) + ns0.HostNasVolume_Def.__bases__ = tuple(bases) + + ns0.HostFileSystemVolume_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostLocalFileSystemVolumeSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostLocalFileSystemVolumeSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostLocalFileSystemVolumeSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localPath"), aname="_localPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostLocalFileSystemVolumeSpec_Def.__bases__: + bases = list(ns0.HostLocalFileSystemVolumeSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostLocalFileSystemVolumeSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostLocalFileSystemVolume_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostLocalFileSystemVolume") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostLocalFileSystemVolume_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostFileSystemVolume_Def not in ns0.HostLocalFileSystemVolume_Def.__bases__: + bases = list(ns0.HostLocalFileSystemVolume_Def.__bases__) + bases.insert(0, ns0.HostFileSystemVolume_Def) + ns0.HostLocalFileSystemVolume_Def.__bases__ = tuple(bases) + + ns0.HostFileSystemVolume_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFirewallConfigRuleSetConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFirewallConfigRuleSetConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFirewallConfigRuleSetConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"rulesetId"), aname="_rulesetId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFirewallConfigRuleSetConfig_Def.__bases__: + bases = list(ns0.HostFirewallConfigRuleSetConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFirewallConfigRuleSetConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostFirewallConfigRuleSetConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostFirewallConfigRuleSetConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostFirewallConfigRuleSetConfig_Def.schema + TClist = [GTD("urn:vim25","HostFirewallConfigRuleSetConfig",lazy=True)(pname=(ns,"HostFirewallConfigRuleSetConfig"), aname="_HostFirewallConfigRuleSetConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostFirewallConfigRuleSetConfig = [] + return + Holder.__name__ = "ArrayOfHostFirewallConfigRuleSetConfig_Holder" + self.pyclass = Holder + + class HostFirewallConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFirewallConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFirewallConfig_Def.schema + TClist = [GTD("urn:vim25","HostFirewallConfigRuleSetConfig",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallDefaultPolicy",lazy=True)(pname=(ns,"defaultBlockingPolicy"), aname="_defaultBlockingPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFirewallConfig_Def.__bases__: + bases = list(ns0.HostFirewallConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFirewallConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFirewallDefaultPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFirewallDefaultPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFirewallDefaultPolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"incomingBlocked"), aname="_incomingBlocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"outgoingBlocked"), aname="_outgoingBlocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFirewallDefaultPolicy_Def.__bases__: + bases = list(ns0.HostFirewallDefaultPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFirewallDefaultPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFirewallInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFirewallInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFirewallInfo_Def.schema + TClist = [GTD("urn:vim25","HostFirewallDefaultPolicy",lazy=True)(pname=(ns,"defaultPolicy"), aname="_defaultPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallRuleset",lazy=True)(pname=(ns,"ruleset"), aname="_ruleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFirewallInfo_Def.__bases__: + bases = list(ns0.HostFirewallInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFirewallInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateDefaultPolicyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateDefaultPolicyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateDefaultPolicyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallDefaultPolicy",lazy=True)(pname=(ns,"defaultPolicy"), aname="_defaultPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._defaultPolicy = None + return + Holder.__name__ = "UpdateDefaultPolicyRequestType_Holder" + self.pyclass = Holder + + class EnableRulesetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EnableRulesetRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.EnableRulesetRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._id = None + return + Holder.__name__ = "EnableRulesetRequestType_Holder" + self.pyclass = Holder + + class DisableRulesetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DisableRulesetRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DisableRulesetRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._id = None + return + Holder.__name__ = "DisableRulesetRequestType_Holder" + self.pyclass = Holder + + class RefreshFirewallRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshFirewallRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshFirewallRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshFirewallRequestType_Holder" + self.pyclass = Holder + + class ResetFirmwareToFactoryDefaultsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetFirmwareToFactoryDefaultsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetFirmwareToFactoryDefaultsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ResetFirmwareToFactoryDefaultsRequestType_Holder" + self.pyclass = Holder + + class BackupFirmwareConfigurationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "BackupFirmwareConfigurationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.BackupFirmwareConfigurationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "BackupFirmwareConfigurationRequestType_Holder" + self.pyclass = Holder + + class QueryFirmwareConfigUploadURLRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryFirmwareConfigUploadURLRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryFirmwareConfigUploadURLRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryFirmwareConfigUploadURLRequestType_Holder" + self.pyclass = Holder + + class RestoreFirmwareConfigurationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RestoreFirmwareConfigurationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RestoreFirmwareConfigurationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._force = None + return + Holder.__name__ = "RestoreFirmwareConfigurationRequestType_Holder" + self.pyclass = Holder + + class HostFlagInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFlagInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFlagInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"backgroundSnapshotsEnabled"), aname="_backgroundSnapshotsEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFlagInfo_Def.__bases__: + bases = list(ns0.HostFlagInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFlagInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostForceMountedInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostForceMountedInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostForceMountedInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"persist"), aname="_persist", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mounted"), aname="_mounted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostForceMountedInfo_Def.__bases__: + bases = list(ns0.HostForceMountedInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostForceMountedInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostHardwareInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostHardwareInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostHardwareInfo_Def.schema + TClist = [GTD("urn:vim25","HostSystemInfo",lazy=True)(pname=(ns,"systemInfo"), aname="_systemInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuPowerManagementInfo",lazy=True)(pname=(ns,"cpuPowerManagementInfo"), aname="_cpuPowerManagementInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuInfo",lazy=True)(pname=(ns,"cpuInfo"), aname="_cpuInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuPackage",lazy=True)(pname=(ns,"cpuPkg"), aname="_cpuPkg", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memorySize"), aname="_memorySize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNumaInfo",lazy=True)(pname=(ns,"numaInfo"), aname="_numaInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPciDevice",lazy=True)(pname=(ns,"pciDevice"), aname="_pciDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeature"), aname="_cpuFeature", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostBIOSInfo",lazy=True)(pname=(ns,"biosInfo"), aname="_biosInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostHardwareInfo_Def.__bases__: + bases = list(ns0.HostHardwareInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostHardwareInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostSystemInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSystemInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSystemInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemIdentificationInfo",lazy=True)(pname=(ns,"otherIdentifyingInfo"), aname="_otherIdentifyingInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSystemInfo_Def.__bases__: + bases = list(ns0.HostSystemInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSystemInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCpuPowerManagementInfoPolicyType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostCpuPowerManagementInfoPolicyType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostCpuPowerManagementInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCpuPowerManagementInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCpuPowerManagementInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"currentPolicy"), aname="_currentPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hardwareSupport"), aname="_hardwareSupport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostCpuPowerManagementInfo_Def.__bases__: + bases = list(ns0.HostCpuPowerManagementInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostCpuPowerManagementInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCpuInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCpuInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCpuInfo_Def.schema + TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"numCpuPackages"), aname="_numCpuPackages", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuThreads"), aname="_numCpuThreads", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hz"), aname="_hz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostCpuInfo_Def.__bases__: + bases = list(ns0.HostCpuInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostCpuInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostCpuPackageVendor_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostCpuPackageVendor") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostCpuPackage_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostCpuPackage") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostCpuPackage_Def.schema + TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"index"), aname="_index", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hz"), aname="_hz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"busHz"), aname="_busHz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"threadId"), aname="_threadId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeature"), aname="_cpuFeature", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostCpuPackage_Def.__bases__: + bases = list(ns0.HostCpuPackage_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostCpuPackage_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostCpuPackage_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostCpuPackage") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostCpuPackage_Def.schema + TClist = [GTD("urn:vim25","HostCpuPackage",lazy=True)(pname=(ns,"HostCpuPackage"), aname="_HostCpuPackage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostCpuPackage = [] + return + Holder.__name__ = "ArrayOfHostCpuPackage_Holder" + self.pyclass = Holder + + class HostNumaInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNumaInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNumaInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNodes"), aname="_numNodes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNumaNode",lazy=True)(pname=(ns,"numaNode"), aname="_numaNode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNumaInfo_Def.__bases__: + bases = list(ns0.HostNumaInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNumaInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNumaNode_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNumaNode") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNumaNode_Def.schema + TClist = [ZSI.TCnumbers.Ibyte(pname=(ns,"typeId"), aname="_typeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"cpuID"), aname="_cpuID", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryRangeBegin"), aname="_memoryRangeBegin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryRangeLength"), aname="_memoryRangeLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNumaNode_Def.__bases__: + bases = list(ns0.HostNumaNode_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNumaNode_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostNumaNode_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostNumaNode") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostNumaNode_Def.schema + TClist = [GTD("urn:vim25","HostNumaNode",lazy=True)(pname=(ns,"HostNumaNode"), aname="_HostNumaNode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostNumaNode = [] + return + Holder.__name__ = "ArrayOfHostNumaNode_Holder" + self.pyclass = Holder + + class HostBIOSInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostBIOSInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostBIOSInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"biosVersion"), aname="_biosVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"releaseDate"), aname="_releaseDate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostBIOSInfo_Def.__bases__: + bases = list(ns0.HostBIOSInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostBIOSInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostHardwareElementStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostHardwareElementStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostHardwareElementInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostHardwareElementInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostHardwareElementInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostHardwareElementInfo_Def.__bases__: + bases = list(ns0.HostHardwareElementInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostHardwareElementInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostHardwareElementInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostHardwareElementInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostHardwareElementInfo_Def.schema + TClist = [GTD("urn:vim25","HostHardwareElementInfo",lazy=True)(pname=(ns,"HostHardwareElementInfo"), aname="_HostHardwareElementInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostHardwareElementInfo = [] + return + Holder.__name__ = "ArrayOfHostHardwareElementInfo_Holder" + self.pyclass = Holder + + class HostStorageOperationalInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostStorageOperationalInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostStorageOperationalInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostStorageOperationalInfo_Def.__bases__: + bases = list(ns0.HostStorageOperationalInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostStorageOperationalInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostStorageOperationalInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostStorageOperationalInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostStorageOperationalInfo_Def.schema + TClist = [GTD("urn:vim25","HostStorageOperationalInfo",lazy=True)(pname=(ns,"HostStorageOperationalInfo"), aname="_HostStorageOperationalInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostStorageOperationalInfo = [] + return + Holder.__name__ = "ArrayOfHostStorageOperationalInfo_Holder" + self.pyclass = Holder + + class HostStorageElementInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostStorageElementInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostStorageElementInfo_Def.schema + TClist = [GTD("urn:vim25","HostStorageOperationalInfo",lazy=True)(pname=(ns,"operationalInfo"), aname="_operationalInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostHardwareElementInfo_Def not in ns0.HostStorageElementInfo_Def.__bases__: + bases = list(ns0.HostStorageElementInfo_Def.__bases__) + bases.insert(0, ns0.HostHardwareElementInfo_Def) + ns0.HostStorageElementInfo_Def.__bases__ = tuple(bases) + + ns0.HostHardwareElementInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostStorageElementInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostStorageElementInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostStorageElementInfo_Def.schema + TClist = [GTD("urn:vim25","HostStorageElementInfo",lazy=True)(pname=(ns,"HostStorageElementInfo"), aname="_HostStorageElementInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostStorageElementInfo = [] + return + Holder.__name__ = "ArrayOfHostStorageElementInfo_Holder" + self.pyclass = Holder + + class HostHardwareStatusInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostHardwareStatusInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostHardwareStatusInfo_Def.schema + TClist = [GTD("urn:vim25","HostHardwareElementInfo",lazy=True)(pname=(ns,"memoryStatusInfo"), aname="_memoryStatusInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHardwareElementInfo",lazy=True)(pname=(ns,"cpuStatusInfo"), aname="_cpuStatusInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostStorageElementInfo",lazy=True)(pname=(ns,"storageStatusInfo"), aname="_storageStatusInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostHardwareStatusInfo_Def.__bases__: + bases = list(ns0.HostHardwareStatusInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostHardwareStatusInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HealthSystemRuntime_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HealthSystemRuntime") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HealthSystemRuntime_Def.schema + TClist = [GTD("urn:vim25","HostSystemHealthInfo",lazy=True)(pname=(ns,"systemHealthInfo"), aname="_systemHealthInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHardwareStatusInfo",lazy=True)(pname=(ns,"hardwareStatusInfo"), aname="_hardwareStatusInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HealthSystemRuntime_Def.__bases__: + bases = list(ns0.HealthSystemRuntime_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HealthSystemRuntime_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RefreshHealthStatusSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshHealthStatusSystemRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshHealthStatusSystemRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshHealthStatusSystemRequestType_Holder" + self.pyclass = Holder + + class ResetSystemHealthInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetSystemHealthInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetSystemHealthInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ResetSystemHealthInfoRequestType_Holder" + self.pyclass = Holder + + class HostHostBusAdapter_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostHostBusAdapter") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostHostBusAdapter_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"bus"), aname="_bus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"driver"), aname="_driver", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pci"), aname="_pci", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostHostBusAdapter_Def.__bases__: + bases = list(ns0.HostHostBusAdapter_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostHostBusAdapter_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostHostBusAdapter_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostHostBusAdapter") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostHostBusAdapter_Def.schema + TClist = [GTD("urn:vim25","HostHostBusAdapter",lazy=True)(pname=(ns,"HostHostBusAdapter"), aname="_HostHostBusAdapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostHostBusAdapter = [] + return + Holder.__name__ = "ArrayOfHostHostBusAdapter_Holder" + self.pyclass = Holder + + class HostParallelScsiHba_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostParallelScsiHba") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostParallelScsiHba_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostHostBusAdapter_Def not in ns0.HostParallelScsiHba_Def.__bases__: + bases = list(ns0.HostParallelScsiHba_Def.__bases__) + bases.insert(0, ns0.HostHostBusAdapter_Def) + ns0.HostParallelScsiHba_Def.__bases__ = tuple(bases) + + ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostBlockHba_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostBlockHba") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostBlockHba_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostHostBusAdapter_Def not in ns0.HostBlockHba_Def.__bases__: + bases = list(ns0.HostBlockHba_Def.__bases__) + bases.insert(0, ns0.HostHostBusAdapter_Def) + ns0.HostBlockHba_Def.__bases__ = tuple(bases) + + ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FibreChannelPortType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FibreChannelPortType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostFibreChannelHba_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFibreChannelHba") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFibreChannelHba_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"portWorldWideName"), aname="_portWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"nodeWorldWideName"), aname="_nodeWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FibreChannelPortType",lazy=True)(pname=(ns,"portType"), aname="_portType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"speed"), aname="_speed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostHostBusAdapter_Def not in ns0.HostFibreChannelHba_Def.__bases__: + bases = list(ns0.HostFibreChannelHba_Def.__bases__) + bases.insert(0, ns0.HostHostBusAdapter_Def) + ns0.HostFibreChannelHba_Def.__bases__ = tuple(bases) + + ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaParamValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaParamValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaParamValue_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"isInherited"), aname="_isInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OptionValue_Def not in ns0.HostInternetScsiHbaParamValue_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaParamValue_Def.__bases__) + bases.insert(0, ns0.OptionValue_Def) + ns0.HostInternetScsiHbaParamValue_Def.__bases__ = tuple(bases) + + ns0.OptionValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostInternetScsiHbaParamValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostInternetScsiHbaParamValue") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostInternetScsiHbaParamValue_Def.schema + TClist = [GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"HostInternetScsiHbaParamValue"), aname="_HostInternetScsiHbaParamValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostInternetScsiHbaParamValue = [] + return + Holder.__name__ = "ArrayOfHostInternetScsiHbaParamValue_Holder" + self.pyclass = Holder + + class HostInternetScsiHbaDiscoveryCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaDiscoveryCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"iSnsDiscoverySettable"), aname="_iSnsDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"slpDiscoverySettable"), aname="_slpDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"staticTargetDiscoverySettable"), aname="_staticTargetDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sendTargetsDiscoverySettable"), aname="_sendTargetsDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class InternetScsiSnsDiscoveryMethod_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "InternetScsiSnsDiscoveryMethod") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class SlpDiscoveryMethod_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SlpDiscoveryMethod") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostInternetScsiHbaDiscoveryProperties_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaDiscoveryProperties") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaDiscoveryProperties_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"iSnsDiscoveryEnabled"), aname="_iSnsDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iSnsDiscoveryMethod"), aname="_iSnsDiscoveryMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iSnsHost"), aname="_iSnsHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"slpDiscoveryEnabled"), aname="_slpDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"slpDiscoveryMethod"), aname="_slpDiscoveryMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"slpHost"), aname="_slpHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"staticTargetDiscoveryEnabled"), aname="_staticTargetDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sendTargetsDiscoveryEnabled"), aname="_sendTargetsDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDiscoveryProperties_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaDiscoveryProperties_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaDiscoveryProperties_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaChapAuthenticationType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaChapAuthenticationType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostInternetScsiHbaAuthenticationCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaAuthenticationCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"chapAuthSettable"), aname="_chapAuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"krb5AuthSettable"), aname="_krb5AuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"srpAuthSettable"), aname="_srpAuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"spkmAuthSettable"), aname="_spkmAuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mutualChapSettable"), aname="_mutualChapSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetChapSettable"), aname="_targetChapSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetMutualChapSettable"), aname="_targetMutualChapSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaAuthenticationProperties_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaAuthenticationProperties") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaAuthenticationProperties_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"chapAuthEnabled"), aname="_chapAuthEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"chapName"), aname="_chapName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"chapSecret"), aname="_chapSecret", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"chapAuthenticationType"), aname="_chapAuthenticationType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"chapInherited"), aname="_chapInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mutualChapName"), aname="_mutualChapName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mutualChapSecret"), aname="_mutualChapSecret", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mutualChapAuthenticationType"), aname="_mutualChapAuthenticationType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mutualChapInherited"), aname="_mutualChapInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaAuthenticationProperties_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaAuthenticationProperties_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaAuthenticationProperties_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaDigestType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaDigestType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostInternetScsiHbaDigestCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaDigestCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaDigestCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"headerDigestSettable"), aname="_headerDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dataDigestSettable"), aname="_dataDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetHeaderDigestSettable"), aname="_targetHeaderDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetDataDigestSettable"), aname="_targetDataDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDigestCapabilities_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaDigestCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaDigestCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaDigestProperties_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaDigestProperties") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaDigestProperties_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"headerDigestType"), aname="_headerDigestType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"headerDigestInherited"), aname="_headerDigestInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dataDigestType"), aname="_dataDigestType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dataDigestInherited"), aname="_dataDigestInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDigestProperties_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaDigestProperties_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaDigestProperties_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaIPCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaIPCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaIPCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"addressSettable"), aname="_addressSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipConfigurationMethodSettable"), aname="_ipConfigurationMethodSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"subnetMaskSettable"), aname="_subnetMaskSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"defaultGatewaySettable"), aname="_defaultGatewaySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"primaryDnsServerAddressSettable"), aname="_primaryDnsServerAddressSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"alternateDnsServerAddressSettable"), aname="_alternateDnsServerAddressSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipv6Supported"), aname="_ipv6Supported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"arpRedirectSettable"), aname="_arpRedirectSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mtuSettable"), aname="_mtuSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hostNameAsTargetAddress"), aname="_hostNameAsTargetAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaIPCapabilities_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaIPCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaIPCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaIPProperties_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaIPProperties") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaIPProperties_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpConfigurationEnabled"), aname="_dhcpConfigurationEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultGateway"), aname="_defaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"primaryDnsServerAddress"), aname="_primaryDnsServerAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"alternateDnsServerAddress"), aname="_alternateDnsServerAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipv6Address"), aname="_ipv6Address", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipv6SubnetMask"), aname="_ipv6SubnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipv6DefaultGateway"), aname="_ipv6DefaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"arpRedirectEnabled"), aname="_arpRedirectEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"jumboFramesEnabled"), aname="_jumboFramesEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaIPProperties_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaIPProperties_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaIPProperties_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHbaSendTarget_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaSendTarget") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaSendTarget_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"supportedAdvancedOptions"), aname="_supportedAdvancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"advancedOptions"), aname="_advancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaSendTarget_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaSendTarget_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaSendTarget_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostInternetScsiHbaSendTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostInternetScsiHbaSendTarget") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostInternetScsiHbaSendTarget_Def.schema + TClist = [GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"HostInternetScsiHbaSendTarget"), aname="_HostInternetScsiHbaSendTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostInternetScsiHbaSendTarget = [] + return + Holder.__name__ = "ArrayOfHostInternetScsiHbaSendTarget_Holder" + self.pyclass = Holder + + class HostInternetScsiHbaStaticTarget_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaStaticTarget") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaStaticTarget_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"supportedAdvancedOptions"), aname="_supportedAdvancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"advancedOptions"), aname="_advancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaStaticTarget_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaStaticTarget_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaStaticTarget_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostInternetScsiHbaStaticTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostInternetScsiHbaStaticTarget") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostInternetScsiHbaStaticTarget_Def.schema + TClist = [GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"HostInternetScsiHbaStaticTarget"), aname="_HostInternetScsiHbaStaticTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostInternetScsiHbaStaticTarget = [] + return + Holder.__name__ = "ArrayOfHostInternetScsiHbaStaticTarget_Holder" + self.pyclass = Holder + + class HostInternetScsiHbaTargetSet_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHbaTargetSet") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHbaTargetSet_Def.schema + TClist = [GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"staticTargets"), aname="_staticTargets", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"sendTargets"), aname="_sendTargets", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaTargetSet_Def.__bases__: + bases = list(ns0.HostInternetScsiHbaTargetSet_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostInternetScsiHbaTargetSet_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiHba_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiHba") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiHba_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"isSoftwareBased"), aname="_isSoftwareBased", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDiscoveryCapabilities",lazy=True)(pname=(ns,"discoveryCapabilities"), aname="_discoveryCapabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDiscoveryProperties",lazy=True)(pname=(ns,"discoveryProperties"), aname="_discoveryProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationCapabilities",lazy=True)(pname=(ns,"authenticationCapabilities"), aname="_authenticationCapabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestCapabilities",lazy=True)(pname=(ns,"digestCapabilities"), aname="_digestCapabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaIPCapabilities",lazy=True)(pname=(ns,"ipCapabilities"), aname="_ipCapabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaIPProperties",lazy=True)(pname=(ns,"ipProperties"), aname="_ipProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"supportedAdvancedOptions"), aname="_supportedAdvancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"advancedOptions"), aname="_advancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiAlias"), aname="_iScsiAlias", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"configuredSendTarget"), aname="_configuredSendTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"configuredStaticTarget"), aname="_configuredStaticTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSpeedMb"), aname="_maxSpeedMb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"currentSpeedMb"), aname="_currentSpeedMb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostHostBusAdapter_Def not in ns0.HostInternetScsiHba_Def.__bases__: + bases = list(ns0.HostInternetScsiHba_Def.__bases__) + bases.insert(0, ns0.HostHostBusAdapter_Def) + ns0.HostInternetScsiHba_Def.__bases__ = tuple(bases) + + ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProxySwitchSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProxySwitchSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProxySwitchSpec_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberBacking",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostProxySwitchSpec_Def.__bases__: + bases = list(ns0.HostProxySwitchSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostProxySwitchSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProxySwitchConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProxySwitchConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProxySwitchConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostProxySwitchConfig_Def.__bases__: + bases = list(ns0.HostProxySwitchConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostProxySwitchConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostProxySwitchConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostProxySwitchConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostProxySwitchConfig_Def.schema + TClist = [GTD("urn:vim25","HostProxySwitchConfig",lazy=True)(pname=(ns,"HostProxySwitchConfig"), aname="_HostProxySwitchConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostProxySwitchConfig = [] + return + Holder.__name__ = "ArrayOfHostProxySwitchConfig_Holder" + self.pyclass = Holder + + class HostProxySwitch_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProxySwitch") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProxySwitch_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"dvsUuid"), aname="_dvsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dvsName"), aname="_dvsName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPortsAvailable"), aname="_numPortsAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"uplinkPort"), aname="_uplinkPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostProxySwitch_Def.__bases__: + bases = list(ns0.HostProxySwitch_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostProxySwitch_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostProxySwitch_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostProxySwitch") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostProxySwitch_Def.schema + TClist = [GTD("urn:vim25","HostProxySwitch",lazy=True)(pname=(ns,"HostProxySwitch"), aname="_HostProxySwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostProxySwitch = [] + return + Holder.__name__ = "ArrayOfHostProxySwitch_Holder" + self.pyclass = Holder + + class HostIpConfigIpV6AddressConfigType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostIpConfigIpV6AddressConfigType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostIpConfigIpV6AddressStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostIpConfigIpV6AddressStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostIpConfigIpV6Address_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpConfigIpV6Address") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpConfigIpV6Address_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"prefixLength"), aname="_prefixLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"origin"), aname="_origin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dadState"), aname="_dadState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lifetime"), aname="_lifetime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpConfigIpV6Address_Def.__bases__: + bases = list(ns0.HostIpConfigIpV6Address_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpConfigIpV6Address_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostIpConfigIpV6Address_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostIpConfigIpV6Address") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostIpConfigIpV6Address_Def.schema + TClist = [GTD("urn:vim25","HostIpConfigIpV6Address",lazy=True)(pname=(ns,"HostIpConfigIpV6Address"), aname="_HostIpConfigIpV6Address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostIpConfigIpV6Address = [] + return + Holder.__name__ = "ArrayOfHostIpConfigIpV6Address_Holder" + self.pyclass = Holder + + class HostIpConfigIpV6AddressConfiguration_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpConfigIpV6AddressConfiguration") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpConfigIpV6AddressConfiguration_Def.schema + TClist = [GTD("urn:vim25","HostIpConfigIpV6Address",lazy=True)(pname=(ns,"ipV6Address"), aname="_ipV6Address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoConfigurationEnabled"), aname="_autoConfigurationEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpV6Enabled"), aname="_dhcpV6Enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpConfigIpV6AddressConfiguration_Def.__bases__: + bases = list(ns0.HostIpConfigIpV6AddressConfiguration_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpConfigIpV6AddressConfiguration_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpConfig_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpConfigIpV6AddressConfiguration",lazy=True)(pname=(ns,"ipV6Config"), aname="_ipV6Config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpConfig_Def.__bases__: + bases = list(ns0.HostIpConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpRouteConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpRouteConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpRouteConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"defaultGateway"), aname="_defaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gatewayDevice"), aname="_gatewayDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipV6DefaultGateway"), aname="_ipV6DefaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipV6GatewayDevice"), aname="_ipV6GatewayDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpRouteConfig_Def.__bases__: + bases = list(ns0.HostIpRouteConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpRouteConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpRouteConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpRouteConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpRouteConfigSpec_Def.schema + TClist = [GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"gatewayDeviceConnection"), aname="_gatewayDeviceConnection", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"ipV6GatewayDeviceConnection"), aname="_ipV6GatewayDeviceConnection", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostIpRouteConfig_Def not in ns0.HostIpRouteConfigSpec_Def.__bases__: + bases = list(ns0.HostIpRouteConfigSpec_Def.__bases__) + bases.insert(0, ns0.HostIpRouteConfig_Def) + ns0.HostIpRouteConfigSpec_Def.__bases__ = tuple(bases) + + ns0.HostIpRouteConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpRouteEntry_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpRouteEntry") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpRouteEntry_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"prefixLength"), aname="_prefixLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpRouteEntry_Def.__bases__: + bases = list(ns0.HostIpRouteEntry_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpRouteEntry_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostIpRouteEntry_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostIpRouteEntry") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostIpRouteEntry_Def.schema + TClist = [GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"HostIpRouteEntry"), aname="_HostIpRouteEntry", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostIpRouteEntry = [] + return + Holder.__name__ = "ArrayOfHostIpRouteEntry_Holder" + self.pyclass = Holder + + class HostIpRouteOp_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpRouteOp") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpRouteOp_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"route"), aname="_route", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpRouteOp_Def.__bases__: + bases = list(ns0.HostIpRouteOp_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpRouteOp_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostIpRouteOp_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostIpRouteOp") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostIpRouteOp_Def.schema + TClist = [GTD("urn:vim25","HostIpRouteOp",lazy=True)(pname=(ns,"HostIpRouteOp"), aname="_HostIpRouteOp", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostIpRouteOp = [] + return + Holder.__name__ = "ArrayOfHostIpRouteOp_Holder" + self.pyclass = Holder + + class HostIpRouteTableConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpRouteTableConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpRouteTableConfig_Def.schema + TClist = [GTD("urn:vim25","HostIpRouteOp",lazy=True)(pname=(ns,"ipRoute"), aname="_ipRoute", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteOp",lazy=True)(pname=(ns,"ipv6Route"), aname="_ipv6Route", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpRouteTableConfig_Def.__bases__: + bases = list(ns0.HostIpRouteTableConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpRouteTableConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpRouteTableInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpRouteTableInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpRouteTableInfo_Def.schema + TClist = [GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"ipRoute"), aname="_ipRoute", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"ipv6Route"), aname="_ipv6Route", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpRouteTableInfo_Def.__bases__: + bases = list(ns0.HostIpRouteTableInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpRouteTableInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostIpmiInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostIpmiInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostIpmiInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"bmcIpAddress"), aname="_bmcIpAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bmcMacAddress"), aname="_bmcMacAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"login"), aname="_login", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostIpmiInfo_Def.__bases__: + bases = list(ns0.HostIpmiInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostIpmiInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class KernelModuleSectionInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "KernelModuleSectionInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.KernelModuleSectionInfo_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"address"), aname="_address", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"length"), aname="_length", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.KernelModuleSectionInfo_Def.__bases__: + bases = list(ns0.KernelModuleSectionInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.KernelModuleSectionInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class KernelModuleInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "KernelModuleInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.KernelModuleInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"optionString"), aname="_optionString", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"loaded"), aname="_loaded", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"useCount"), aname="_useCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"readOnlySection"), aname="_readOnlySection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"writableSection"), aname="_writableSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"textSection"), aname="_textSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"dataSection"), aname="_dataSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"bssSection"), aname="_bssSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.KernelModuleInfo_Def.__bases__: + bases = list(ns0.KernelModuleInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.KernelModuleInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfKernelModuleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfKernelModuleInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfKernelModuleInfo_Def.schema + TClist = [GTD("urn:vim25","KernelModuleInfo",lazy=True)(pname=(ns,"KernelModuleInfo"), aname="_KernelModuleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._KernelModuleInfo = [] + return + Holder.__name__ = "ArrayOfKernelModuleInfo_Holder" + self.pyclass = Holder + + class QueryModulesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryModulesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryModulesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryModulesRequestType_Holder" + self.pyclass = Holder + + class UpdateModuleOptionStringRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateModuleOptionStringRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateModuleOptionStringRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"options"), aname="_options", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._options = None + return + Holder.__name__ = "UpdateModuleOptionStringRequestType_Holder" + self.pyclass = Holder + + class QueryConfiguredModuleOptionStringRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryConfiguredModuleOptionStringRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryConfiguredModuleOptionStringRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + return + Holder.__name__ = "QueryConfiguredModuleOptionStringRequestType_Holder" + self.pyclass = Holder + + class HostLicenseSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostLicenseSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostLicenseSpec_Def.schema + TClist = [GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"editionKey"), aname="_editionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"disabledFeatureKey"), aname="_disabledFeatureKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"enabledFeatureKey"), aname="_enabledFeatureKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostLicenseSpec_Def.__bases__: + bases = list(ns0.HostLicenseSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostLicenseSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LinkDiscoveryProtocolConfigProtocolType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LinkDiscoveryProtocolConfigProtocolType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LinkDiscoveryProtocolConfigOperationType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "LinkDiscoveryProtocolConfigOperationType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class LinkDiscoveryProtocolConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LinkDiscoveryProtocolConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LinkDiscoveryProtocolConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"protocol"), aname="_protocol", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.LinkDiscoveryProtocolConfig_Def.__bases__: + bases = list(ns0.LinkDiscoveryProtocolConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.LinkDiscoveryProtocolConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostAccountSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostAccountSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostAccountSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostAccountSpec_Def.__bases__: + bases = list(ns0.HostAccountSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostAccountSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostAccountSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostAccountSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostAccountSpec_Def.schema + TClist = [GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"HostAccountSpec"), aname="_HostAccountSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostAccountSpec = [] + return + Holder.__name__ = "ArrayOfHostAccountSpec_Holder" + self.pyclass = Holder + + class HostPosixAccountSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPosixAccountSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPosixAccountSpec_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"posixId"), aname="_posixId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shellAccess"), aname="_shellAccess", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostAccountSpec_Def not in ns0.HostPosixAccountSpec_Def.__bases__: + bases = list(ns0.HostPosixAccountSpec_Def.__bases__) + bases.insert(0, ns0.HostAccountSpec_Def) + ns0.HostPosixAccountSpec_Def.__bases__ = tuple(bases) + + ns0.HostAccountSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CreateUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateUserRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateUserRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._user = None + return + Holder.__name__ = "CreateUserRequestType_Holder" + self.pyclass = Holder + + class UpdateUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateUserRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateUserRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._user = None + return + Holder.__name__ = "UpdateUserRequestType_Holder" + self.pyclass = Holder + + class CreateGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateGroupRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateGroupRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._group = None + return + Holder.__name__ = "CreateGroupRequestType_Holder" + self.pyclass = Holder + + class RemoveUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveUserRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveUserRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._userName = None + return + Holder.__name__ = "RemoveUserRequestType_Holder" + self.pyclass = Holder + + class RemoveGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveGroupRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveGroupRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"groupName"), aname="_groupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._groupName = None + return + Holder.__name__ = "RemoveGroupRequestType_Holder" + self.pyclass = Holder + + class AssignUserToGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AssignUserToGroupRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AssignUserToGroupRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._user = None + self._group = None + return + Holder.__name__ = "AssignUserToGroupRequestType_Holder" + self.pyclass = Holder + + class UnassignUserFromGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UnassignUserFromGroupRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UnassignUserFromGroupRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._user = None + self._group = None + return + Holder.__name__ = "UnassignUserFromGroupRequestType_Holder" + self.pyclass = Holder + + class HostLowLevelProvisioningManagerReloadTarget_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostLowLevelProvisioningManagerReloadTarget") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ServiceConsoleReservationInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ServiceConsoleReservationInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ServiceConsoleReservationInfo_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"serviceConsoleReservedCfg"), aname="_serviceConsoleReservedCfg", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"serviceConsoleReserved"), aname="_serviceConsoleReserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ServiceConsoleReservationInfo_Def.__bases__: + bases = list(ns0.ServiceConsoleReservationInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ServiceConsoleReservationInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineMemoryAllocationPolicy_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineMemoryAllocationPolicy") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineMemoryReservationInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineMemoryReservationInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineMemoryReservationInfo_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineMin"), aname="_virtualMachineMin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineMax"), aname="_virtualMachineMax", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineReserved"), aname="_virtualMachineReserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"allocationPolicy"), aname="_allocationPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineMemoryReservationInfo_Def.__bases__: + bases = list(ns0.VirtualMachineMemoryReservationInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineMemoryReservationInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineMemoryReservationSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineMemoryReservationSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineMemoryReservationSpec_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineReserved"), aname="_virtualMachineReserved", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"allocationPolicy"), aname="_allocationPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineMemoryReservationSpec_Def.__bases__: + bases = list(ns0.VirtualMachineMemoryReservationSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineMemoryReservationSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReconfigureServiceConsoleReservationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureServiceConsoleReservationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureServiceConsoleReservationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"cfgBytes"), aname="_cfgBytes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._cfgBytes = None + return + Holder.__name__ = "ReconfigureServiceConsoleReservationRequestType_Holder" + self.pyclass = Holder + + class ReconfigureVirtualMachineReservationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureVirtualMachineReservationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureVirtualMachineReservationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMemoryReservationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "ReconfigureVirtualMachineReservationRequestType_Holder" + self.pyclass = Holder + + class HostMemorySpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMemorySpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMemorySpec_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"serviceConsoleReservation"), aname="_serviceConsoleReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMemorySpec_Def.__bases__: + bases = list(ns0.HostMemorySpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMemorySpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostMountMode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostMountMode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostMountInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMountInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMountInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"accessMode"), aname="_accessMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"accessible"), aname="_accessible", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMountInfo_Def.__bases__: + bases = list(ns0.HostMountInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMountInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MultipathState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "MultipathState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostMultipathInfoLogicalUnitPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathInfoLogicalUnitPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathInfoLogicalUnitPolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMultipathInfoLogicalUnitPolicy_Def.__bases__: + bases = list(ns0.HostMultipathInfoLogicalUnitPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMultipathInfoLogicalUnitPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathInfoLogicalUnitStorageArrayTypePolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.__bases__: + bases = list(ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostMultipathInfoFixedLogicalUnitPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathInfoFixedLogicalUnitPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"prefer"), aname="_prefer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostMultipathInfoLogicalUnitPolicy_Def not in ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.__bases__: + bases = list(ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.__bases__) + bases.insert(0, ns0.HostMultipathInfoLogicalUnitPolicy_Def) + ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.__bases__ = tuple(bases) + + ns0.HostMultipathInfoLogicalUnitPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostMultipathInfoLogicalUnit_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathInfoLogicalUnit") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathInfoLogicalUnit_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoLogicalUnitPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoLogicalUnitStorageArrayTypePolicy",lazy=True)(pname=(ns,"storageArrayTypePolicy"), aname="_storageArrayTypePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMultipathInfoLogicalUnit_Def.__bases__: + bases = list(ns0.HostMultipathInfoLogicalUnit_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMultipathInfoLogicalUnit_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostMultipathInfoLogicalUnit_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostMultipathInfoLogicalUnit") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostMultipathInfoLogicalUnit_Def.schema + TClist = [GTD("urn:vim25","HostMultipathInfoLogicalUnit",lazy=True)(pname=(ns,"HostMultipathInfoLogicalUnit"), aname="_HostMultipathInfoLogicalUnit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostMultipathInfoLogicalUnit = [] + return + Holder.__name__ = "ArrayOfHostMultipathInfoLogicalUnit_Holder" + self.pyclass = Holder + + class HostMultipathInfoPath_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathInfoPath") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathInfoPath_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathState"), aname="_pathState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"isWorkingPath"), aname="_isWorkingPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTargetTransport",lazy=True)(pname=(ns,"transport"), aname="_transport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMultipathInfoPath_Def.__bases__: + bases = list(ns0.HostMultipathInfoPath_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMultipathInfoPath_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostMultipathInfoPath_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostMultipathInfoPath") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostMultipathInfoPath_Def.schema + TClist = [GTD("urn:vim25","HostMultipathInfoPath",lazy=True)(pname=(ns,"HostMultipathInfoPath"), aname="_HostMultipathInfoPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostMultipathInfoPath = [] + return + Holder.__name__ = "ArrayOfHostMultipathInfoPath_Holder" + self.pyclass = Holder + + class HostMultipathInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathInfo_Def.schema + TClist = [GTD("urn:vim25","HostMultipathInfoLogicalUnit",lazy=True)(pname=(ns,"lun"), aname="_lun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMultipathInfo_Def.__bases__: + bases = list(ns0.HostMultipathInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMultipathInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostMultipathStateInfoPath_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathStateInfoPath") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathStateInfoPath_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathState"), aname="_pathState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMultipathStateInfoPath_Def.__bases__: + bases = list(ns0.HostMultipathStateInfoPath_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMultipathStateInfoPath_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostMultipathStateInfoPath_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostMultipathStateInfoPath") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostMultipathStateInfoPath_Def.schema + TClist = [GTD("urn:vim25","HostMultipathStateInfoPath",lazy=True)(pname=(ns,"HostMultipathStateInfoPath"), aname="_HostMultipathStateInfoPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostMultipathStateInfoPath = [] + return + Holder.__name__ = "ArrayOfHostMultipathStateInfoPath_Holder" + self.pyclass = Holder + + class HostMultipathStateInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMultipathStateInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMultipathStateInfo_Def.schema + TClist = [GTD("urn:vim25","HostMultipathStateInfoPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostMultipathStateInfo_Def.__bases__: + bases = list(ns0.HostMultipathStateInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostMultipathStateInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNatServicePortForwardSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNatServicePortForwardSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNatServicePortForwardSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostPort"), aname="_hostPort", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"guestPort"), aname="_guestPort", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestIpAddress"), aname="_guestIpAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNatServicePortForwardSpec_Def.__bases__: + bases = list(ns0.HostNatServicePortForwardSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNatServicePortForwardSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostNatServicePortForwardSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostNatServicePortForwardSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostNatServicePortForwardSpec_Def.schema + TClist = [GTD("urn:vim25","HostNatServicePortForwardSpec",lazy=True)(pname=(ns,"HostNatServicePortForwardSpec"), aname="_HostNatServicePortForwardSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostNatServicePortForwardSpec = [] + return + Holder.__name__ = "ArrayOfHostNatServicePortForwardSpec_Holder" + self.pyclass = Holder + + class HostNatServiceNameServiceSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNatServiceNameServiceSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNatServiceNameServiceSpec_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"dnsAutoDetect"), aname="_dnsAutoDetect", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsPolicy"), aname="_dnsPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dnsRetries"), aname="_dnsRetries", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dnsTimeout"), aname="_dnsTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsNameServer"), aname="_dnsNameServer", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"nbdsTimeout"), aname="_nbdsTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"nbnsRetries"), aname="_nbnsRetries", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"nbnsTimeout"), aname="_nbnsTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNatServiceNameServiceSpec_Def.__bases__: + bases = list(ns0.HostNatServiceNameServiceSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNatServiceNameServiceSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNatServiceSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNatServiceSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNatServiceSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"virtualSwitch"), aname="_virtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"activeFtp"), aname="_activeFtp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"allowAnyOui"), aname="_allowAnyOui", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"configPort"), aname="_configPort", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipGatewayAddress"), aname="_ipGatewayAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"udpTimeout"), aname="_udpTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServicePortForwardSpec",lazy=True)(pname=(ns,"portForward"), aname="_portForward", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceNameServiceSpec",lazy=True)(pname=(ns,"nameService"), aname="_nameService", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNatServiceSpec_Def.__bases__: + bases = list(ns0.HostNatServiceSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNatServiceSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNatServiceConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNatServiceConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNatServiceConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNatServiceConfig_Def.__bases__: + bases = list(ns0.HostNatServiceConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNatServiceConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostNatServiceConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostNatServiceConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostNatServiceConfig_Def.schema + TClist = [GTD("urn:vim25","HostNatServiceConfig",lazy=True)(pname=(ns,"HostNatServiceConfig"), aname="_HostNatServiceConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostNatServiceConfig = [] + return + Holder.__name__ = "ArrayOfHostNatServiceConfig_Holder" + self.pyclass = Holder + + class HostNatService_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNatService") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNatService_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNatService_Def.__bases__: + bases = list(ns0.HostNatService_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNatService_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostNatService_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostNatService") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostNatService_Def.schema + TClist = [GTD("urn:vim25","HostNatService",lazy=True)(pname=(ns,"HostNatService"), aname="_HostNatService", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostNatService = [] + return + Holder.__name__ = "ArrayOfHostNatService_Holder" + self.pyclass = Holder + + class HostNetCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"canSetPhysicalNicLinkSpeed"), aname="_canSetPhysicalNicLinkSpeed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsNicTeaming"), aname="_supportsNicTeaming", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicTeamingPolicy"), aname="_nicTeamingPolicy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsVlan"), aname="_supportsVlan", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"usesServiceConsoleNic"), aname="_usesServiceConsoleNic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsNetworkHints"), aname="_supportsNetworkHints", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxPortGroupsPerVswitch"), aname="_maxPortGroupsPerVswitch", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vswitchConfigSupported"), aname="_vswitchConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vnicConfigSupported"), aname="_vnicConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipRouteConfigSupported"), aname="_ipRouteConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dnsConfigSupported"), aname="_dnsConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpOnVnicSupported"), aname="_dhcpOnVnicSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipV6Supported"), aname="_ipV6Supported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetCapabilities_Def.__bases__: + bases = list(ns0.HostNetCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNetOffloadCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetOffloadCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetOffloadCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"csumOffload"), aname="_csumOffload", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tcpSegmentation"), aname="_tcpSegmentation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"zeroCopyXmit"), aname="_zeroCopyXmit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetOffloadCapabilities_Def.__bases__: + bases = list(ns0.HostNetOffloadCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetOffloadCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNetworkConfigResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetworkConfigResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetworkConfigResult_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vnicDevice"), aname="_vnicDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"consoleVnicDevice"), aname="_consoleVnicDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetworkConfigResult_Def.__bases__: + bases = list(ns0.HostNetworkConfigResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetworkConfigResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNetworkConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetworkConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetworkConfig_Def.schema + TClist = [GTD("urn:vim25","HostVirtualSwitchConfig",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitchConfig",lazy=True)(pname=(ns,"proxySwitch"), aname="_proxySwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupConfig",lazy=True)(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicConfig",lazy=True)(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicConfig",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicConfig",lazy=True)(pname=(ns,"consoleVnic"), aname="_consoleVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDnsConfig",lazy=True)(pname=(ns,"dnsConfig"), aname="_dnsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"ipRouteConfig"), aname="_ipRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"consoleIpRouteConfig"), aname="_consoleIpRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteTableConfig",lazy=True)(pname=(ns,"routeTableConfig"), aname="_routeTableConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpServiceConfig",lazy=True)(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceConfig",lazy=True)(pname=(ns,"nat"), aname="_nat", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipV6Enabled"), aname="_ipV6Enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetworkConfig_Def.__bases__: + bases = list(ns0.HostNetworkConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetworkConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNetworkInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetworkInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetworkInfo_Def.schema + TClist = [GTD("urn:vim25","HostVirtualSwitch",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitch",lazy=True)(pname=(ns,"proxySwitch"), aname="_proxySwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroup",lazy=True)(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNic",lazy=True)(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"consoleVnic"), aname="_consoleVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDnsConfig",lazy=True)(pname=(ns,"dnsConfig"), aname="_dnsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"ipRouteConfig"), aname="_ipRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"consoleIpRouteConfig"), aname="_consoleIpRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteTableInfo",lazy=True)(pname=(ns,"routeTableInfo"), aname="_routeTableInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpService",lazy=True)(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatService",lazy=True)(pname=(ns,"nat"), aname="_nat", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipV6Enabled"), aname="_ipV6Enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetworkInfo_Def.__bases__: + bases = list(ns0.HostNetworkInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetworkInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNetworkSecurityPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetworkSecurityPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetworkSecurityPolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"allowPromiscuous"), aname="_allowPromiscuous", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"macChanges"), aname="_macChanges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"forgedTransmits"), aname="_forgedTransmits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetworkSecurityPolicy_Def.__bases__: + bases = list(ns0.HostNetworkSecurityPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetworkSecurityPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNetworkTrafficShapingPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetworkTrafficShapingPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetworkTrafficShapingPolicy_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"averageBandwidth"), aname="_averageBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"peakBandwidth"), aname="_peakBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"burstSize"), aname="_burstSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetworkTrafficShapingPolicy_Def.__bases__: + bases = list(ns0.HostNetworkTrafficShapingPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetworkTrafficShapingPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNicFailureCriteria_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNicFailureCriteria") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNicFailureCriteria_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"checkSpeed"), aname="_checkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"speed"), aname="_speed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"checkDuplex"), aname="_checkDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fullDuplex"), aname="_fullDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"checkErrorPercent"), aname="_checkErrorPercent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"percentage"), aname="_percentage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"checkBeacon"), aname="_checkBeacon", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNicFailureCriteria_Def.__bases__: + bases = list(ns0.HostNicFailureCriteria_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNicFailureCriteria_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNicOrderPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNicOrderPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNicOrderPolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"activeNic"), aname="_activeNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"standbyNic"), aname="_standbyNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNicOrderPolicy_Def.__bases__: + bases = list(ns0.HostNicOrderPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNicOrderPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNicTeamingPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNicTeamingPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNicTeamingPolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"reversePolicy"), aname="_reversePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"notifySwitches"), aname="_notifySwitches", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rollingOrder"), aname="_rollingOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNicFailureCriteria",lazy=True)(pname=(ns,"failureCriteria"), aname="_failureCriteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNicOrderPolicy",lazy=True)(pname=(ns,"nicOrder"), aname="_nicOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNicTeamingPolicy_Def.__bases__: + bases = list(ns0.HostNicTeamingPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNicTeamingPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNetworkPolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNetworkPolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNetworkPolicy_Def.schema + TClist = [GTD("urn:vim25","HostNetworkSecurityPolicy",lazy=True)(pname=(ns,"security"), aname="_security", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNicTeamingPolicy",lazy=True)(pname=(ns,"nicTeaming"), aname="_nicTeaming", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetOffloadCapabilities",lazy=True)(pname=(ns,"offloadPolicy"), aname="_offloadPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkTrafficShapingPolicy",lazy=True)(pname=(ns,"shapingPolicy"), aname="_shapingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNetworkPolicy_Def.__bases__: + bases = list(ns0.HostNetworkPolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNetworkPolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateNetworkConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateNetworkConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateNetworkConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeMode"), aname="_changeMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + self._changeMode = None + return + Holder.__name__ = "UpdateNetworkConfigRequestType_Holder" + self.pyclass = Holder + + class UpdateDnsConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateDnsConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateDnsConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDnsConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + return + Holder.__name__ = "UpdateDnsConfigRequestType_Holder" + self.pyclass = Holder + + class UpdateIpRouteConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateIpRouteConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateIpRouteConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + return + Holder.__name__ = "UpdateIpRouteConfigRequestType_Holder" + self.pyclass = Holder + + class UpdateConsoleIpRouteConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateConsoleIpRouteConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateConsoleIpRouteConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + return + Holder.__name__ = "UpdateConsoleIpRouteConfigRequestType_Holder" + self.pyclass = Holder + + class UpdateIpRouteTableConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateIpRouteTableConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateIpRouteTableConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteTableConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + return + Holder.__name__ = "UpdateIpRouteTableConfigRequestType_Holder" + self.pyclass = Holder + + class AddVirtualSwitchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddVirtualSwitchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddVirtualSwitchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vswitchName = None + self._spec = None + return + Holder.__name__ = "AddVirtualSwitchRequestType_Holder" + self.pyclass = Holder + + class RemoveVirtualSwitchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveVirtualSwitchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveVirtualSwitchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vswitchName = None + return + Holder.__name__ = "RemoveVirtualSwitchRequestType_Holder" + self.pyclass = Holder + + class UpdateVirtualSwitchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateVirtualSwitchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateVirtualSwitchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vswitchName = None + self._spec = None + return + Holder.__name__ = "UpdateVirtualSwitchRequestType_Holder" + self.pyclass = Holder + + class AddPortGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddPortGroupRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddPortGroupRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"portgrp"), aname="_portgrp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._portgrp = None + return + Holder.__name__ = "AddPortGroupRequestType_Holder" + self.pyclass = Holder + + class RemovePortGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemovePortGroupRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemovePortGroupRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pgName"), aname="_pgName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._pgName = None + return + Holder.__name__ = "RemovePortGroupRequestType_Holder" + self.pyclass = Holder + + class UpdatePortGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdatePortGroupRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdatePortGroupRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pgName"), aname="_pgName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"portgrp"), aname="_portgrp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._pgName = None + self._portgrp = None + return + Holder.__name__ = "UpdatePortGroupRequestType_Holder" + self.pyclass = Holder + + class UpdatePhysicalNicLinkSpeedRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdatePhysicalNicLinkSpeedRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdatePhysicalNicLinkSpeedRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"linkSpeed"), aname="_linkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = None + self._linkSpeed = None + return + Holder.__name__ = "UpdatePhysicalNicLinkSpeedRequestType_Holder" + self.pyclass = Holder + + class QueryNetworkHintRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryNetworkHintRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryNetworkHintRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = [] + return + Holder.__name__ = "QueryNetworkHintRequestType_Holder" + self.pyclass = Holder + + class AddVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddVirtualNicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddVirtualNicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._portgroup = None + self._nic = None + return + Holder.__name__ = "AddVirtualNicRequestType_Holder" + self.pyclass = Holder + + class RemoveVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveVirtualNicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveVirtualNicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = None + return + Holder.__name__ = "RemoveVirtualNicRequestType_Holder" + self.pyclass = Holder + + class UpdateVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateVirtualNicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateVirtualNicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = None + self._nic = None + return + Holder.__name__ = "UpdateVirtualNicRequestType_Holder" + self.pyclass = Holder + + class AddServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddServiceConsoleVirtualNicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddServiceConsoleVirtualNicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._portgroup = None + self._nic = None + return + Holder.__name__ = "AddServiceConsoleVirtualNicRequestType_Holder" + self.pyclass = Holder + + class RemoveServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveServiceConsoleVirtualNicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveServiceConsoleVirtualNicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = None + return + Holder.__name__ = "RemoveServiceConsoleVirtualNicRequestType_Holder" + self.pyclass = Holder + + class UpdateServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateServiceConsoleVirtualNicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateServiceConsoleVirtualNicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = None + self._nic = None + return + Holder.__name__ = "UpdateServiceConsoleVirtualNicRequestType_Holder" + self.pyclass = Holder + + class RestartServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RestartServiceConsoleVirtualNicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RestartServiceConsoleVirtualNicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = None + return + Holder.__name__ = "RestartServiceConsoleVirtualNicRequestType_Holder" + self.pyclass = Holder + + class RefreshNetworkSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshNetworkSystemRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshNetworkSystemRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshNetworkSystemRequestType_Holder" + self.pyclass = Holder + + class HostNtpConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNtpConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNtpConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"server"), aname="_server", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNtpConfig_Def.__bases__: + bases = list(ns0.HostNtpConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNtpConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostNumericSensorHealthState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostNumericSensorHealthState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostNumericSensorType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostNumericSensorType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostNumericSensorInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostNumericSensorInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostNumericSensorInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"healthState"), aname="_healthState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"currentReading"), aname="_currentReading", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"unitModifier"), aname="_unitModifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"baseUnits"), aname="_baseUnits", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rateUnits"), aname="_rateUnits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sensorType"), aname="_sensorType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostNumericSensorInfo_Def.__bases__: + bases = list(ns0.HostNumericSensorInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostNumericSensorInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostNumericSensorInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostNumericSensorInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostNumericSensorInfo_Def.schema + TClist = [GTD("urn:vim25","HostNumericSensorInfo",lazy=True)(pname=(ns,"HostNumericSensorInfo"), aname="_HostNumericSensorInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostNumericSensorInfo = [] + return + Holder.__name__ = "ArrayOfHostNumericSensorInfo_Holder" + self.pyclass = Holder + + class HostPatchManagerResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPatchManagerResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPatchManagerResult_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"xmlResult"), aname="_xmlResult", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPatchManagerResult_Def.__bases__: + bases = list(ns0.HostPatchManagerResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPatchManagerResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostPatchManagerReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostPatchManagerReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostPatchManagerIntegrityStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostPatchManagerIntegrityStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostPatchManagerInstallState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostPatchManagerInstallState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostPatchManagerStatusPrerequisitePatch_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPatchManagerStatusPrerequisitePatch") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPatchManagerStatusPrerequisitePatch_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installState"), aname="_installState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPatchManagerStatusPrerequisitePatch_Def.__bases__: + bases = list(ns0.HostPatchManagerStatusPrerequisitePatch_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPatchManagerStatusPrerequisitePatch_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPatchManagerStatusPrerequisitePatch_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPatchManagerStatusPrerequisitePatch") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPatchManagerStatusPrerequisitePatch_Def.schema + TClist = [GTD("urn:vim25","HostPatchManagerStatusPrerequisitePatch",lazy=True)(pname=(ns,"HostPatchManagerStatusPrerequisitePatch"), aname="_HostPatchManagerStatusPrerequisitePatch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPatchManagerStatusPrerequisitePatch = [] + return + Holder.__name__ = "ArrayOfHostPatchManagerStatusPrerequisitePatch_Holder" + self.pyclass = Holder + + class HostPatchManagerStatus_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPatchManagerStatus") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPatchManagerStatus_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"applicable"), aname="_applicable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"integrity"), aname="_integrity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installed"), aname="_installed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installState"), aname="_installState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerStatusPrerequisitePatch",lazy=True)(pname=(ns,"prerequisitePatch"), aname="_prerequisitePatch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"restartRequired"), aname="_restartRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"reconnectRequired"), aname="_reconnectRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmOffRequired"), aname="_vmOffRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supersededPatchIds"), aname="_supersededPatchIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPatchManagerStatus_Def.__bases__: + bases = list(ns0.HostPatchManagerStatus_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPatchManagerStatus_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPatchManagerStatus_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPatchManagerStatus") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPatchManagerStatus_Def.schema + TClist = [GTD("urn:vim25","HostPatchManagerStatus",lazy=True)(pname=(ns,"HostPatchManagerStatus"), aname="_HostPatchManagerStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPatchManagerStatus = [] + return + Holder.__name__ = "ArrayOfHostPatchManagerStatus_Holder" + self.pyclass = Holder + + class HostPatchManagerLocator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPatchManagerLocator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPatchManagerLocator_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"proxy"), aname="_proxy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPatchManagerLocator_Def.__bases__: + bases = list(ns0.HostPatchManagerLocator_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPatchManagerLocator_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostPatchManagerPatchManagerOperationSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPatchManagerPatchManagerOperationSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPatchManagerPatchManagerOperationSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"proxy"), aname="_proxy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cmdOption"), aname="_cmdOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPatchManagerPatchManagerOperationSpec_Def.__bases__: + bases = list(ns0.HostPatchManagerPatchManagerOperationSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPatchManagerPatchManagerOperationSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CheckHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckHostPatchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckHostPatchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._metaUrls = [] + self._bundleUrls = [] + self._spec = None + return + Holder.__name__ = "CheckHostPatchRequestType_Holder" + self.pyclass = Holder + + class ScanHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ScanHostPatchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ScanHostPatchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerLocator",lazy=True)(pname=(ns,"repository"), aname="_repository", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"updateID"), aname="_updateID", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._repository = None + self._updateID = [] + return + Holder.__name__ = "ScanHostPatchRequestType_Holder" + self.pyclass = Holder + + class ScanHostPatchV2RequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ScanHostPatchV2RequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ScanHostPatchV2RequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._metaUrls = [] + self._bundleUrls = [] + self._spec = None + return + Holder.__name__ = "ScanHostPatchV2RequestType_Holder" + self.pyclass = Holder + + class StageHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StageHostPatchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StageHostPatchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vibUrls"), aname="_vibUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._metaUrls = [] + self._bundleUrls = [] + self._vibUrls = [] + self._spec = None + return + Holder.__name__ = "StageHostPatchRequestType_Holder" + self.pyclass = Holder + + class InstallHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "InstallHostPatchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.InstallHostPatchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerLocator",lazy=True)(pname=(ns,"repository"), aname="_repository", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"updateID"), aname="_updateID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._repository = None + self._updateID = None + self._force = None + return + Holder.__name__ = "InstallHostPatchRequestType_Holder" + self.pyclass = Holder + + class InstallHostPatchV2RequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "InstallHostPatchV2RequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.InstallHostPatchV2RequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vibUrls"), aname="_vibUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._metaUrls = [] + self._bundleUrls = [] + self._vibUrls = [] + self._spec = None + return + Holder.__name__ = "InstallHostPatchV2RequestType_Holder" + self.pyclass = Holder + + class UninstallHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UninstallHostPatchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UninstallHostPatchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bulletinIds"), aname="_bulletinIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._bulletinIds = [] + self._spec = None + return + Holder.__name__ = "UninstallHostPatchRequestType_Holder" + self.pyclass = Holder + + class QueryHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryHostPatchRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryHostPatchRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "QueryHostPatchRequestType_Holder" + self.pyclass = Holder + + class HostPathSelectionPolicyOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPathSelectionPolicyOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPathSelectionPolicyOption_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPathSelectionPolicyOption_Def.__bases__: + bases = list(ns0.HostPathSelectionPolicyOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPathSelectionPolicyOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPathSelectionPolicyOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPathSelectionPolicyOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPathSelectionPolicyOption_Def.schema + TClist = [GTD("urn:vim25","HostPathSelectionPolicyOption",lazy=True)(pname=(ns,"HostPathSelectionPolicyOption"), aname="_HostPathSelectionPolicyOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPathSelectionPolicyOption = [] + return + Holder.__name__ = "ArrayOfHostPathSelectionPolicyOption_Holder" + self.pyclass = Holder + + class HostPciDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPciDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPciDevice_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"classId"), aname="_classId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"bus"), aname="_bus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"slot"), aname="_slot", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"function"), aname="_function", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"vendorId"), aname="_vendorId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"subVendorId"), aname="_subVendorId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendorName"), aname="_vendorName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"subDeviceId"), aname="_subDeviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentBridge"), aname="_parentBridge", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPciDevice_Def.__bases__: + bases = list(ns0.HostPciDevice_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPciDevice_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPciDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPciDevice") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPciDevice_Def.schema + TClist = [GTD("urn:vim25","HostPciDevice",lazy=True)(pname=(ns,"HostPciDevice"), aname="_HostPciDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPciDevice = [] + return + Holder.__name__ = "ArrayOfHostPciDevice_Holder" + self.pyclass = Holder + + class HostPciPassthruConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPciPassthruConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPciPassthruConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruEnabled"), aname="_passthruEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPciPassthruConfig_Def.__bases__: + bases = list(ns0.HostPciPassthruConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPciPassthruConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPciPassthruConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPciPassthruConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPciPassthruConfig_Def.schema + TClist = [GTD("urn:vim25","HostPciPassthruConfig",lazy=True)(pname=(ns,"HostPciPassthruConfig"), aname="_HostPciPassthruConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPciPassthruConfig = [] + return + Holder.__name__ = "ArrayOfHostPciPassthruConfig_Holder" + self.pyclass = Holder + + class HostPciPassthruInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPciPassthruInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPciPassthruInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dependentDevice"), aname="_dependentDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruEnabled"), aname="_passthruEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruCapable"), aname="_passthruCapable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruActive"), aname="_passthruActive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPciPassthruInfo_Def.__bases__: + bases = list(ns0.HostPciPassthruInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPciPassthruInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPciPassthruInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPciPassthruInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPciPassthruInfo_Def.schema + TClist = [GTD("urn:vim25","HostPciPassthruInfo",lazy=True)(pname=(ns,"HostPciPassthruInfo"), aname="_HostPciPassthruInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPciPassthruInfo = [] + return + Holder.__name__ = "ArrayOfHostPciPassthruInfo_Holder" + self.pyclass = Holder + + class RefreshRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshRequestType_Holder" + self.pyclass = Holder + + class UpdatePassthruConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdatePassthruConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdatePassthruConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPciPassthruConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = [] + return + Holder.__name__ = "UpdatePassthruConfigRequestType_Holder" + self.pyclass = Holder + + class PhysicalNicSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicSpec_Def.schema + TClist = [GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"linkSpeed"), aname="_linkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNicSpec_Def.__bases__: + bases = list(ns0.PhysicalNicSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNicSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PhysicalNicConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNicConfig_Def.__bases__: + bases = list(ns0.PhysicalNicConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNicConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPhysicalNicConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPhysicalNicConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPhysicalNicConfig_Def.schema + TClist = [GTD("urn:vim25","PhysicalNicConfig",lazy=True)(pname=(ns,"PhysicalNicConfig"), aname="_PhysicalNicConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PhysicalNicConfig = [] + return + Holder.__name__ = "ArrayOfPhysicalNicConfig_Holder" + self.pyclass = Holder + + class PhysicalNicLinkInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicLinkInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicLinkInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"speedMb"), aname="_speedMb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"duplex"), aname="_duplex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNicLinkInfo_Def.__bases__: + bases = list(ns0.PhysicalNicLinkInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNicLinkInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPhysicalNicLinkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPhysicalNicLinkInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPhysicalNicLinkInfo_Def.schema + TClist = [GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"PhysicalNicLinkInfo"), aname="_PhysicalNicLinkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PhysicalNicLinkInfo = [] + return + Holder.__name__ = "ArrayOfPhysicalNicLinkInfo_Holder" + self.pyclass = Holder + + class PhysicalNicHint_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicHint") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicHint_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNicHint_Def.__bases__: + bases = list(ns0.PhysicalNicHint_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNicHint_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PhysicalNicIpHint_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicIpHint") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicIpHint_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipSubnet"), aname="_ipSubnet", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PhysicalNicHint_Def not in ns0.PhysicalNicIpHint_Def.__bases__: + bases = list(ns0.PhysicalNicIpHint_Def.__bases__) + bases.insert(0, ns0.PhysicalNicHint_Def) + ns0.PhysicalNicIpHint_Def.__bases__ = tuple(bases) + + ns0.PhysicalNicHint_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPhysicalNicIpHint_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPhysicalNicIpHint") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPhysicalNicIpHint_Def.schema + TClist = [GTD("urn:vim25","PhysicalNicIpHint",lazy=True)(pname=(ns,"PhysicalNicIpHint"), aname="_PhysicalNicIpHint", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PhysicalNicIpHint = [] + return + Holder.__name__ = "ArrayOfPhysicalNicIpHint_Holder" + self.pyclass = Holder + + class PhysicalNicNameHint_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicNameHint") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicNameHint_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PhysicalNicHint_Def not in ns0.PhysicalNicNameHint_Def.__bases__: + bases = list(ns0.PhysicalNicNameHint_Def.__bases__) + bases.insert(0, ns0.PhysicalNicHint_Def) + ns0.PhysicalNicNameHint_Def.__bases__ = tuple(bases) + + ns0.PhysicalNicHint_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPhysicalNicNameHint_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPhysicalNicNameHint") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPhysicalNicNameHint_Def.schema + TClist = [GTD("urn:vim25","PhysicalNicNameHint",lazy=True)(pname=(ns,"PhysicalNicNameHint"), aname="_PhysicalNicNameHint", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PhysicalNicNameHint = [] + return + Holder.__name__ = "ArrayOfPhysicalNicNameHint_Holder" + self.pyclass = Holder + + class PhysicalNicHintInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicHintInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicHintInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicIpHint",lazy=True)(pname=(ns,"subnet"), aname="_subnet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicNameHint",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicCdpInfo",lazy=True)(pname=(ns,"connectedSwitchPort"), aname="_connectedSwitchPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNicHintInfo_Def.__bases__: + bases = list(ns0.PhysicalNicHintInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNicHintInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPhysicalNicHintInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPhysicalNicHintInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPhysicalNicHintInfo_Def.schema + TClist = [GTD("urn:vim25","PhysicalNicHintInfo",lazy=True)(pname=(ns,"PhysicalNicHintInfo"), aname="_PhysicalNicHintInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PhysicalNicHintInfo = [] + return + Holder.__name__ = "ArrayOfPhysicalNicHintInfo_Holder" + self.pyclass = Holder + + class PhysicalNicCdpDeviceCapability_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicCdpDeviceCapability") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicCdpDeviceCapability_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"router"), aname="_router", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"transparentBridge"), aname="_transparentBridge", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sourceRouteBridge"), aname="_sourceRouteBridge", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"networkSwitch"), aname="_networkSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"igmpEnabled"), aname="_igmpEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"repeater"), aname="_repeater", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNicCdpDeviceCapability_Def.__bases__: + bases = list(ns0.PhysicalNicCdpDeviceCapability_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNicCdpDeviceCapability_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PhysicalNicCdpInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicCdpInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicCdpInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"cdpVersion"), aname="_cdpVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ttl"), aname="_ttl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"samples"), aname="_samples", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devId"), aname="_devId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portId"), aname="_portId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicCdpDeviceCapability",lazy=True)(pname=(ns,"deviceCapability"), aname="_deviceCapability", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"softwareVersion"), aname="_softwareVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hardwarePlatform"), aname="_hardwarePlatform", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipPrefix"), aname="_ipPrefix", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ipPrefixLen"), aname="_ipPrefixLen", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vlan"), aname="_vlan", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fullDuplex"), aname="_fullDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemName"), aname="_systemName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemOID"), aname="_systemOID", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mgmtAddr"), aname="_mgmtAddr", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"location"), aname="_location", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNicCdpInfo_Def.__bases__: + bases = list(ns0.PhysicalNicCdpInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNicCdpInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PhysicalNic_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNic") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNic_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pci"), aname="_pci", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"driver"), aname="_driver", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"linkSpeed"), aname="_linkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"validLinkSpecification"), aname="_validLinkSpecification", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"wakeOnLanSupported"), aname="_wakeOnLanSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PhysicalNic_Def.__bases__: + bases = list(ns0.PhysicalNic_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PhysicalNic_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPhysicalNic_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPhysicalNic") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPhysicalNic_Def.schema + TClist = [GTD("urn:vim25","PhysicalNic",lazy=True)(pname=(ns,"PhysicalNic"), aname="_PhysicalNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PhysicalNic = [] + return + Holder.__name__ = "ArrayOfPhysicalNic_Holder" + self.pyclass = Holder + + class HostPlugStoreTopologyAdapter_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPlugStoreTopologyAdapter") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPlugStoreTopologyAdapter_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyAdapter_Def.__bases__: + bases = list(ns0.HostPlugStoreTopologyAdapter_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPlugStoreTopologyAdapter_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPlugStoreTopologyAdapter_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPlugStoreTopologyAdapter") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPlugStoreTopologyAdapter_Def.schema + TClist = [GTD("urn:vim25","HostPlugStoreTopologyAdapter",lazy=True)(pname=(ns,"HostPlugStoreTopologyAdapter"), aname="_HostPlugStoreTopologyAdapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPlugStoreTopologyAdapter = [] + return + Holder.__name__ = "ArrayOfHostPlugStoreTopologyAdapter_Holder" + self.pyclass = Holder + + class HostPlugStoreTopologyPath_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPlugStoreTopologyPath") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPlugStoreTopologyPath_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"channelNumber"), aname="_channelNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"targetNumber"), aname="_targetNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lunNumber"), aname="_lunNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyPath_Def.__bases__: + bases = list(ns0.HostPlugStoreTopologyPath_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPlugStoreTopologyPath_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPlugStoreTopologyPath_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPlugStoreTopologyPath") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPlugStoreTopologyPath_Def.schema + TClist = [GTD("urn:vim25","HostPlugStoreTopologyPath",lazy=True)(pname=(ns,"HostPlugStoreTopologyPath"), aname="_HostPlugStoreTopologyPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPlugStoreTopologyPath = [] + return + Holder.__name__ = "ArrayOfHostPlugStoreTopologyPath_Holder" + self.pyclass = Holder + + class HostPlugStoreTopologyDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPlugStoreTopologyDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPlugStoreTopologyDevice_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyDevice_Def.__bases__: + bases = list(ns0.HostPlugStoreTopologyDevice_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPlugStoreTopologyDevice_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPlugStoreTopologyDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPlugStoreTopologyDevice") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPlugStoreTopologyDevice_Def.schema + TClist = [GTD("urn:vim25","HostPlugStoreTopologyDevice",lazy=True)(pname=(ns,"HostPlugStoreTopologyDevice"), aname="_HostPlugStoreTopologyDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPlugStoreTopologyDevice = [] + return + Holder.__name__ = "ArrayOfHostPlugStoreTopologyDevice_Holder" + self.pyclass = Holder + + class HostPlugStoreTopologyPlugin_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPlugStoreTopologyPlugin") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPlugStoreTopologyPlugin_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"claimedPath"), aname="_claimedPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyPlugin_Def.__bases__: + bases = list(ns0.HostPlugStoreTopologyPlugin_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPlugStoreTopologyPlugin_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPlugStoreTopologyPlugin_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPlugStoreTopologyPlugin") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPlugStoreTopologyPlugin_Def.schema + TClist = [GTD("urn:vim25","HostPlugStoreTopologyPlugin",lazy=True)(pname=(ns,"HostPlugStoreTopologyPlugin"), aname="_HostPlugStoreTopologyPlugin", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPlugStoreTopologyPlugin = [] + return + Holder.__name__ = "ArrayOfHostPlugStoreTopologyPlugin_Holder" + self.pyclass = Holder + + class HostPlugStoreTopologyTarget_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPlugStoreTopologyTarget") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPlugStoreTopologyTarget_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTargetTransport",lazy=True)(pname=(ns,"transport"), aname="_transport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyTarget_Def.__bases__: + bases = list(ns0.HostPlugStoreTopologyTarget_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPlugStoreTopologyTarget_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPlugStoreTopologyTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPlugStoreTopologyTarget") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPlugStoreTopologyTarget_Def.schema + TClist = [GTD("urn:vim25","HostPlugStoreTopologyTarget",lazy=True)(pname=(ns,"HostPlugStoreTopologyTarget"), aname="_HostPlugStoreTopologyTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPlugStoreTopologyTarget = [] + return + Holder.__name__ = "ArrayOfHostPlugStoreTopologyTarget_Holder" + self.pyclass = Holder + + class HostPlugStoreTopology_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPlugStoreTopology") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPlugStoreTopology_Def.schema + TClist = [GTD("urn:vim25","HostPlugStoreTopologyAdapter",lazy=True)(pname=(ns,"adapter"), aname="_adapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyTarget",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyPlugin",lazy=True)(pname=(ns,"plugin"), aname="_plugin", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPlugStoreTopology_Def.__bases__: + bases = list(ns0.HostPlugStoreTopology_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPlugStoreTopology_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PortGroupConnecteeType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "PortGroupConnecteeType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostPortGroupSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPortGroupSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPortGroupSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPortGroupSpec_Def.__bases__: + bases = list(ns0.HostPortGroupSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPortGroupSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostPortGroupConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPortGroupConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPortGroupConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPortGroupConfig_Def.__bases__: + bases = list(ns0.HostPortGroupConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPortGroupConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPortGroupConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPortGroupConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPortGroupConfig_Def.schema + TClist = [GTD("urn:vim25","HostPortGroupConfig",lazy=True)(pname=(ns,"HostPortGroupConfig"), aname="_HostPortGroupConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPortGroupConfig = [] + return + Holder.__name__ = "ArrayOfHostPortGroupConfig_Holder" + self.pyclass = Holder + + class HostPortGroupPort_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPortGroupPort") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPortGroupPort_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPortGroupPort_Def.__bases__: + bases = list(ns0.HostPortGroupPort_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPortGroupPort_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPortGroupPort_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPortGroupPort") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPortGroupPort_Def.schema + TClist = [GTD("urn:vim25","HostPortGroupPort",lazy=True)(pname=(ns,"HostPortGroupPort"), aname="_HostPortGroupPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPortGroupPort = [] + return + Holder.__name__ = "ArrayOfHostPortGroupPort_Holder" + self.pyclass = Holder + + class HostPortGroup_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPortGroup") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPortGroup_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupPort",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkPolicy",lazy=True)(pname=(ns,"computedPolicy"), aname="_computedPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostPortGroup_Def.__bases__: + bases = list(ns0.HostPortGroup_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostPortGroup_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPortGroup_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPortGroup") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPortGroup_Def.schema + TClist = [GTD("urn:vim25","HostPortGroup",lazy=True)(pname=(ns,"HostPortGroup"), aname="_HostPortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPortGroup = [] + return + Holder.__name__ = "ArrayOfHostPortGroup_Holder" + self.pyclass = Holder + + class HostResignatureRescanResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostResignatureRescanResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostResignatureRescanResult_Def.schema + TClist = [GTD("urn:vim25","HostVmfsRescanResult",lazy=True)(pname=(ns,"rescan"), aname="_rescan", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"result"), aname="_result", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostResignatureRescanResult_Def.__bases__: + bases = list(ns0.HostResignatureRescanResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostResignatureRescanResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFirewallRuleDirection_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostFirewallRuleDirection") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostFirewallRuleProtocol_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostFirewallRuleProtocol") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostFirewallRule_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFirewallRule") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFirewallRule_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"endPort"), aname="_endPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallRuleDirection",lazy=True)(pname=(ns,"direction"), aname="_direction", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"protocol"), aname="_protocol", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFirewallRule_Def.__bases__: + bases = list(ns0.HostFirewallRule_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFirewallRule_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostFirewallRule_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostFirewallRule") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostFirewallRule_Def.schema + TClist = [GTD("urn:vim25","HostFirewallRule",lazy=True)(pname=(ns,"HostFirewallRule"), aname="_HostFirewallRule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostFirewallRule = [] + return + Holder.__name__ = "ArrayOfHostFirewallRule_Holder" + self.pyclass = Holder + + class HostFirewallRuleset_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFirewallRuleset") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFirewallRuleset_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"required"), aname="_required", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallRule",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostFirewallRuleset_Def.__bases__: + bases = list(ns0.HostFirewallRuleset_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostFirewallRuleset_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostFirewallRuleset_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostFirewallRuleset") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostFirewallRuleset_Def.schema + TClist = [GTD("urn:vim25","HostFirewallRuleset",lazy=True)(pname=(ns,"HostFirewallRuleset"), aname="_HostFirewallRuleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostFirewallRuleset = [] + return + Holder.__name__ = "ArrayOfHostFirewallRuleset_Holder" + self.pyclass = Holder + + class HostRuntimeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostRuntimeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostRuntimeInfo_Def.schema + TClist = [GTD("urn:vim25","HostSystemConnectionState",lazy=True)(pname=(ns,"connectionState"), aname="_connectionState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemPowerState",lazy=True)(pname=(ns,"powerState"), aname="_powerState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inMaintenanceMode"), aname="_inMaintenanceMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"bootTime"), aname="_bootTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HealthSystemRuntime",lazy=True)(pname=(ns,"healthSystemRuntime"), aname="_healthSystemRuntime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTpmDigestInfo",lazy=True)(pname=(ns,"tpmPcrValues"), aname="_tpmPcrValues", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostRuntimeInfo_Def.__bases__: + bases = list(ns0.HostRuntimeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostRuntimeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostScsiDiskPartition_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostScsiDiskPartition") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostScsiDiskPartition_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskName"), aname="_diskName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostScsiDiskPartition_Def.__bases__: + bases = list(ns0.HostScsiDiskPartition_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostScsiDiskPartition_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostScsiDiskPartition_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostScsiDiskPartition") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostScsiDiskPartition_Def.schema + TClist = [GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"HostScsiDiskPartition"), aname="_HostScsiDiskPartition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostScsiDiskPartition = [] + return + Holder.__name__ = "ArrayOfHostScsiDiskPartition_Holder" + self.pyclass = Holder + + class HostScsiDisk_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostScsiDisk") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostScsiDisk_Def.schema + TClist = [GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScsiLun_Def not in ns0.HostScsiDisk_Def.__bases__: + bases = list(ns0.HostScsiDisk_Def.__bases__) + bases.insert(0, ns0.ScsiLun_Def) + ns0.HostScsiDisk_Def.__bases__ = tuple(bases) + + ns0.ScsiLun_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostScsiDisk_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostScsiDisk") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostScsiDisk_Def.schema + TClist = [GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"HostScsiDisk"), aname="_HostScsiDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostScsiDisk = [] + return + Holder.__name__ = "ArrayOfHostScsiDisk_Holder" + self.pyclass = Holder + + class ScsiLunType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ScsiLunType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ScsiLunCapabilities_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScsiLunCapabilities") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScsiLunCapabilities_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"updateDisplayNameSupported"), aname="_updateDisplayNameSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ScsiLunCapabilities_Def.__bases__: + bases = list(ns0.ScsiLunCapabilities_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ScsiLunCapabilities_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScsiLunDurableName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScsiLunDurableName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScsiLunDurableName_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"namespace"), aname="_namespace", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"namespaceId"), aname="_namespaceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"data"), aname="_data", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ScsiLunDurableName_Def.__bases__: + bases = list(ns0.ScsiLunDurableName_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ScsiLunDurableName_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfScsiLunDurableName_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfScsiLunDurableName") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfScsiLunDurableName_Def.schema + TClist = [GTD("urn:vim25","ScsiLunDurableName",lazy=True)(pname=(ns,"ScsiLunDurableName"), aname="_ScsiLunDurableName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ScsiLunDurableName = [] + return + Holder.__name__ = "ArrayOfScsiLunDurableName_Holder" + self.pyclass = Holder + + class ScsiLunState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ScsiLunState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ScsiLunDescriptorQuality_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ScsiLunDescriptorQuality") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ScsiLunDescriptor_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScsiLunDescriptor") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScsiLunDescriptor_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"quality"), aname="_quality", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ScsiLunDescriptor_Def.__bases__: + bases = list(ns0.ScsiLunDescriptor_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ScsiLunDescriptor_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfScsiLunDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfScsiLunDescriptor") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfScsiLunDescriptor_Def.schema + TClist = [GTD("urn:vim25","ScsiLunDescriptor",lazy=True)(pname=(ns,"ScsiLunDescriptor"), aname="_ScsiLunDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ScsiLunDescriptor = [] + return + Holder.__name__ = "ArrayOfScsiLunDescriptor_Holder" + self.pyclass = Holder + + class ScsiLun_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScsiLun") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScsiLun_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunDescriptor",lazy=True)(pname=(ns,"descriptor"), aname="_descriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"canonicalName"), aname="_canonicalName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"displayName"), aname="_displayName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lunType"), aname="_lunType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"revision"), aname="_revision", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"scsiLevel"), aname="_scsiLevel", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"serialNumber"), aname="_serialNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunDurableName",lazy=True)(pname=(ns,"durableName"), aname="_durableName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunDurableName",lazy=True)(pname=(ns,"alternateName"), aname="_alternateName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"standardInquiry"), aname="_standardInquiry", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"queueDepth"), aname="_queueDepth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operationalState"), aname="_operationalState", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunCapabilities",lazy=True)(pname=(ns,"capabilities"), aname="_capabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDevice_Def not in ns0.ScsiLun_Def.__bases__: + bases = list(ns0.ScsiLun_Def.__bases__) + bases.insert(0, ns0.HostDevice_Def) + ns0.ScsiLun_Def.__bases__ = tuple(bases) + + ns0.HostDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfScsiLun_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfScsiLun") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfScsiLun_Def.schema + TClist = [GTD("urn:vim25","ScsiLun",lazy=True)(pname=(ns,"ScsiLun"), aname="_ScsiLun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ScsiLun = [] + return + Holder.__name__ = "ArrayOfScsiLun_Holder" + self.pyclass = Holder + + class HostScsiTopologyInterface_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostScsiTopologyInterface") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostScsiTopologyInterface_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiTopologyTarget",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostScsiTopologyInterface_Def.__bases__: + bases = list(ns0.HostScsiTopologyInterface_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostScsiTopologyInterface_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostScsiTopologyInterface_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostScsiTopologyInterface") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostScsiTopologyInterface_Def.schema + TClist = [GTD("urn:vim25","HostScsiTopologyInterface",lazy=True)(pname=(ns,"HostScsiTopologyInterface"), aname="_HostScsiTopologyInterface", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostScsiTopologyInterface = [] + return + Holder.__name__ = "ArrayOfHostScsiTopologyInterface_Holder" + self.pyclass = Holder + + class HostScsiTopologyTarget_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostScsiTopologyTarget") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostScsiTopologyTarget_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"target"), aname="_target", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiTopologyLun",lazy=True)(pname=(ns,"lun"), aname="_lun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTargetTransport",lazy=True)(pname=(ns,"transport"), aname="_transport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostScsiTopologyTarget_Def.__bases__: + bases = list(ns0.HostScsiTopologyTarget_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostScsiTopologyTarget_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostScsiTopologyTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostScsiTopologyTarget") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostScsiTopologyTarget_Def.schema + TClist = [GTD("urn:vim25","HostScsiTopologyTarget",lazy=True)(pname=(ns,"HostScsiTopologyTarget"), aname="_HostScsiTopologyTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostScsiTopologyTarget = [] + return + Holder.__name__ = "ArrayOfHostScsiTopologyTarget_Holder" + self.pyclass = Holder + + class HostScsiTopologyLun_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostScsiTopologyLun") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostScsiTopologyLun_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"scsiLun"), aname="_scsiLun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostScsiTopologyLun_Def.__bases__: + bases = list(ns0.HostScsiTopologyLun_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostScsiTopologyLun_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostScsiTopologyLun_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostScsiTopologyLun") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostScsiTopologyLun_Def.schema + TClist = [GTD("urn:vim25","HostScsiTopologyLun",lazy=True)(pname=(ns,"HostScsiTopologyLun"), aname="_HostScsiTopologyLun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostScsiTopologyLun = [] + return + Holder.__name__ = "ArrayOfHostScsiTopologyLun_Holder" + self.pyclass = Holder + + class HostScsiTopology_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostScsiTopology") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostScsiTopology_Def.schema + TClist = [GTD("urn:vim25","HostScsiTopologyInterface",lazy=True)(pname=(ns,"adapter"), aname="_adapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostScsiTopology_Def.__bases__: + bases = list(ns0.HostScsiTopology_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostScsiTopology_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostSecuritySpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSecuritySpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSecuritySpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"adminPassword"), aname="_adminPassword", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSecuritySpec_Def.__bases__: + bases = list(ns0.HostSecuritySpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSecuritySpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostServicePolicy_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostServicePolicy") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostService_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostService") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostService_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"required"), aname="_required", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uninstallable"), aname="_uninstallable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"running"), aname="_running", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ruleset"), aname="_ruleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostService_Def.__bases__: + bases = list(ns0.HostService_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostService_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostService_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostService") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostService_Def.schema + TClist = [GTD("urn:vim25","HostService",lazy=True)(pname=(ns,"HostService"), aname="_HostService", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostService = [] + return + Holder.__name__ = "ArrayOfHostService_Holder" + self.pyclass = Holder + + class HostServiceConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostServiceConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostServiceConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"serviceId"), aname="_serviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"startupPolicy"), aname="_startupPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostServiceConfig_Def.__bases__: + bases = list(ns0.HostServiceConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostServiceConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostServiceConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostServiceConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostServiceConfig_Def.schema + TClist = [GTD("urn:vim25","HostServiceConfig",lazy=True)(pname=(ns,"HostServiceConfig"), aname="_HostServiceConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostServiceConfig = [] + return + Holder.__name__ = "ArrayOfHostServiceConfig_Holder" + self.pyclass = Holder + + class HostServiceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostServiceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostServiceInfo_Def.schema + TClist = [GTD("urn:vim25","HostService",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostServiceInfo_Def.__bases__: + bases = list(ns0.HostServiceInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostServiceInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateServicePolicyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateServicePolicyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateServicePolicyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._id = None + self._policy = None + return + Holder.__name__ = "UpdateServicePolicyRequestType_Holder" + self.pyclass = Holder + + class StartServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StartServiceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StartServiceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._id = None + return + Holder.__name__ = "StartServiceRequestType_Holder" + self.pyclass = Holder + + class StopServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "StopServiceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.StopServiceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._id = None + return + Holder.__name__ = "StopServiceRequestType_Holder" + self.pyclass = Holder + + class RestartServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RestartServiceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RestartServiceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._id = None + return + Holder.__name__ = "RestartServiceRequestType_Holder" + self.pyclass = Holder + + class UninstallServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UninstallServiceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UninstallServiceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._id = None + return + Holder.__name__ = "UninstallServiceRequestType_Holder" + self.pyclass = Holder + + class RefreshServicesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshServicesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshServicesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshServicesRequestType_Holder" + self.pyclass = Holder + + class HostSnmpDestination_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSnmpDestination") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSnmpDestination_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"community"), aname="_community", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSnmpDestination_Def.__bases__: + bases = list(ns0.HostSnmpDestination_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSnmpDestination_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostSnmpDestination_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostSnmpDestination") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostSnmpDestination_Def.schema + TClist = [GTD("urn:vim25","HostSnmpDestination",lazy=True)(pname=(ns,"HostSnmpDestination"), aname="_HostSnmpDestination", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostSnmpDestination = [] + return + Holder.__name__ = "ArrayOfHostSnmpDestination_Holder" + self.pyclass = Holder + + class HostSnmpConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSnmpConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSnmpConfigSpec_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"readOnlyCommunities"), aname="_readOnlyCommunities", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSnmpDestination",lazy=True)(pname=(ns,"trapTargets"), aname="_trapTargets", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSnmpConfigSpec_Def.__bases__: + bases = list(ns0.HostSnmpConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSnmpConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostSnmpAgentCapability_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostSnmpAgentCapability") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostSnmpSystemAgentLimits_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSnmpSystemAgentLimits") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSnmpSystemAgentLimits_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"maxReadOnlyCommunities"), aname="_maxReadOnlyCommunities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxTrapDestinations"), aname="_maxTrapDestinations", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCommunityLength"), aname="_maxCommunityLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxBufferSize"), aname="_maxBufferSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSnmpAgentCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSnmpSystemAgentLimits_Def.__bases__: + bases = list(ns0.HostSnmpSystemAgentLimits_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSnmpSystemAgentLimits_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ReconfigureSnmpAgentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureSnmpAgentRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureSnmpAgentRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSnmpConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "ReconfigureSnmpAgentRequestType_Holder" + self.pyclass = Holder + + class SendTestNotificationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SendTestNotificationRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SendTestNotificationRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "SendTestNotificationRequestType_Holder" + self.pyclass = Holder + + class HostSslThumbprintInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSslThumbprintInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSslThumbprintInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprints"), aname="_sslThumbprints", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSslThumbprintInfo_Def.__bases__: + bases = list(ns0.HostSslThumbprintInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSslThumbprintInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostStorageArrayTypePolicyOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostStorageArrayTypePolicyOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostStorageArrayTypePolicyOption_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostStorageArrayTypePolicyOption_Def.__bases__: + bases = list(ns0.HostStorageArrayTypePolicyOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostStorageArrayTypePolicyOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostStorageArrayTypePolicyOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostStorageArrayTypePolicyOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostStorageArrayTypePolicyOption_Def.schema + TClist = [GTD("urn:vim25","HostStorageArrayTypePolicyOption",lazy=True)(pname=(ns,"HostStorageArrayTypePolicyOption"), aname="_HostStorageArrayTypePolicyOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostStorageArrayTypePolicyOption = [] + return + Holder.__name__ = "ArrayOfHostStorageArrayTypePolicyOption_Holder" + self.pyclass = Holder + + class HostStorageDeviceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostStorageDeviceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostStorageDeviceInfo_Def.schema + TClist = [GTD("urn:vim25","HostHostBusAdapter",lazy=True)(pname=(ns,"hostBusAdapter"), aname="_hostBusAdapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLun",lazy=True)(pname=(ns,"scsiLun"), aname="_scsiLun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiTopology",lazy=True)(pname=(ns,"scsiTopology"), aname="_scsiTopology", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfo",lazy=True)(pname=(ns,"multipathInfo"), aname="_multipathInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopology",lazy=True)(pname=(ns,"plugStoreTopology"), aname="_plugStoreTopology", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"softwareInternetScsiEnabled"), aname="_softwareInternetScsiEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostStorageDeviceInfo_Def.__bases__: + bases = list(ns0.HostStorageDeviceInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostStorageDeviceInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RetrieveDiskPartitionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveDiskPartitionInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveDiskPartitionInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._devicePath = [] + return + Holder.__name__ = "RetrieveDiskPartitionInfoRequestType_Holder" + self.pyclass = Holder + + class ComputeDiskPartitionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ComputeDiskPartitionInfoRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ComputeDiskPartitionInfoRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._devicePath = None + self._layout = None + return + Holder.__name__ = "ComputeDiskPartitionInfoRequestType_Holder" + self.pyclass = Holder + + class ComputeDiskPartitionInfoForResizeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ComputeDiskPartitionInfoForResizeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ComputeDiskPartitionInfoForResizeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"blockRange"), aname="_blockRange", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._partition = None + self._blockRange = None + return + Holder.__name__ = "ComputeDiskPartitionInfoForResizeRequestType_Holder" + self.pyclass = Holder + + class UpdateDiskPartitionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateDiskPartitionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateDiskPartitionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._devicePath = None + self._spec = None + return + Holder.__name__ = "UpdateDiskPartitionsRequestType_Holder" + self.pyclass = Holder + + class FormatVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "FormatVmfsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.FormatVmfsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVmfsSpec",lazy=True)(pname=(ns,"createSpec"), aname="_createSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._createSpec = None + return + Holder.__name__ = "FormatVmfsRequestType_Holder" + self.pyclass = Holder + + class RescanVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RescanVmfsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RescanVmfsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RescanVmfsRequestType_Holder" + self.pyclass = Holder + + class AttachVmfsExtentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AttachVmfsExtentRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AttachVmfsExtentRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsPath"), aname="_vmfsPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vmfsPath = None + self._extent = None + return + Holder.__name__ = "AttachVmfsExtentRequestType_Holder" + self.pyclass = Holder + + class ExpandVmfsExtentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ExpandVmfsExtentRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ExpandVmfsExtentRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsPath"), aname="_vmfsPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vmfsPath = None + self._extent = None + return + Holder.__name__ = "ExpandVmfsExtentRequestType_Holder" + self.pyclass = Holder + + class UpgradeVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpgradeVmfsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpgradeVmfsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsPath"), aname="_vmfsPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vmfsPath = None + return + Holder.__name__ = "UpgradeVmfsRequestType_Holder" + self.pyclass = Holder + + class UpgradeVmLayoutRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpgradeVmLayoutRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpgradeVmLayoutRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "UpgradeVmLayoutRequestType_Holder" + self.pyclass = Holder + + class QueryUnresolvedVmfsVolumeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryUnresolvedVmfsVolumeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryUnresolvedVmfsVolumeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryUnresolvedVmfsVolumeRequestType_Holder" + self.pyclass = Holder + + class ResolveMultipleUnresolvedVmfsVolumesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResolveMultipleUnresolvedVmfsVolumesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostUnresolvedVmfsResolutionSpec",lazy=True)(pname=(ns,"resolutionSpec"), aname="_resolutionSpec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._resolutionSpec = [] + return + Holder.__name__ = "ResolveMultipleUnresolvedVmfsVolumesRequestType_Holder" + self.pyclass = Holder + + class UnmountForceMountedVmfsVolumeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UnmountForceMountedVmfsVolumeRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UnmountForceMountedVmfsVolumeRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsUuid"), aname="_vmfsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vmfsUuid = None + return + Holder.__name__ = "UnmountForceMountedVmfsVolumeRequestType_Holder" + self.pyclass = Holder + + class RescanHbaRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RescanHbaRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RescanHbaRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hbaDevice"), aname="_hbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._hbaDevice = None + return + Holder.__name__ = "RescanHbaRequestType_Holder" + self.pyclass = Holder + + class RescanAllHbaRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RescanAllHbaRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RescanAllHbaRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RescanAllHbaRequestType_Holder" + self.pyclass = Holder + + class UpdateSoftwareInternetScsiEnabledRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateSoftwareInternetScsiEnabledRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._enabled = None + return + Holder.__name__ = "UpdateSoftwareInternetScsiEnabledRequestType_Holder" + self.pyclass = Holder + + class UpdateInternetScsiDiscoveryPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateInternetScsiDiscoveryPropertiesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDiscoveryProperties",lazy=True)(pname=(ns,"discoveryProperties"), aname="_discoveryProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._discoveryProperties = None + return + Holder.__name__ = "UpdateInternetScsiDiscoveryPropertiesRequestType_Holder" + self.pyclass = Holder + + class UpdateInternetScsiAuthenticationPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateInternetScsiAuthenticationPropertiesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaTargetSet",lazy=True)(pname=(ns,"targetSet"), aname="_targetSet", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._authenticationProperties = None + self._targetSet = None + return + Holder.__name__ = "UpdateInternetScsiAuthenticationPropertiesRequestType_Holder" + self.pyclass = Holder + + class UpdateInternetScsiDigestPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateInternetScsiDigestPropertiesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateInternetScsiDigestPropertiesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaTargetSet",lazy=True)(pname=(ns,"targetSet"), aname="_targetSet", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._targetSet = None + self._digestProperties = None + return + Holder.__name__ = "UpdateInternetScsiDigestPropertiesRequestType_Holder" + self.pyclass = Holder + + class UpdateInternetScsiAdvancedOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateInternetScsiAdvancedOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaTargetSet",lazy=True)(pname=(ns,"targetSet"), aname="_targetSet", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"options"), aname="_options", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._targetSet = None + self._options = [] + return + Holder.__name__ = "UpdateInternetScsiAdvancedOptionsRequestType_Holder" + self.pyclass = Holder + + class UpdateInternetScsiIPPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateInternetScsiIPPropertiesRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateInternetScsiIPPropertiesRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaIPProperties",lazy=True)(pname=(ns,"ipProperties"), aname="_ipProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._ipProperties = None + return + Holder.__name__ = "UpdateInternetScsiIPPropertiesRequestType_Holder" + self.pyclass = Holder + + class UpdateInternetScsiNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateInternetScsiNameRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateInternetScsiNameRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._iScsiName = None + return + Holder.__name__ = "UpdateInternetScsiNameRequestType_Holder" + self.pyclass = Holder + + class UpdateInternetScsiAliasRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateInternetScsiAliasRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateInternetScsiAliasRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiAlias"), aname="_iScsiAlias", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._iScsiAlias = None + return + Holder.__name__ = "UpdateInternetScsiAliasRequestType_Holder" + self.pyclass = Holder + + class AddInternetScsiSendTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddInternetScsiSendTargetsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddInternetScsiSendTargetsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._targets = [] + return + Holder.__name__ = "AddInternetScsiSendTargetsRequestType_Holder" + self.pyclass = Holder + + class RemoveInternetScsiSendTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveInternetScsiSendTargetsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveInternetScsiSendTargetsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._targets = [] + return + Holder.__name__ = "RemoveInternetScsiSendTargetsRequestType_Holder" + self.pyclass = Holder + + class AddInternetScsiStaticTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "AddInternetScsiStaticTargetsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.AddInternetScsiStaticTargetsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._targets = [] + return + Holder.__name__ = "AddInternetScsiStaticTargetsRequestType_Holder" + self.pyclass = Holder + + class RemoveInternetScsiStaticTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveInternetScsiStaticTargetsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveInternetScsiStaticTargetsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._iScsiHbaDevice = None + self._targets = [] + return + Holder.__name__ = "RemoveInternetScsiStaticTargetsRequestType_Holder" + self.pyclass = Holder + + class EnableMultipathPathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "EnableMultipathPathRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.EnableMultipathPathRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathName"), aname="_pathName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._pathName = None + return + Holder.__name__ = "EnableMultipathPathRequestType_Holder" + self.pyclass = Holder + + class DisableMultipathPathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DisableMultipathPathRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DisableMultipathPathRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathName"), aname="_pathName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._pathName = None + return + Holder.__name__ = "DisableMultipathPathRequestType_Holder" + self.pyclass = Holder + + class SetMultipathLunPolicyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SetMultipathLunPolicyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SetMultipathLunPolicyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lunId"), aname="_lunId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoLogicalUnitPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._lunId = None + self._policy = None + return + Holder.__name__ = "SetMultipathLunPolicyRequestType_Holder" + self.pyclass = Holder + + class QueryPathSelectionPolicyOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryPathSelectionPolicyOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryPathSelectionPolicyOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryPathSelectionPolicyOptionsRequestType_Holder" + self.pyclass = Holder + + class QueryStorageArrayTypePolicyOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryStorageArrayTypePolicyOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "QueryStorageArrayTypePolicyOptionsRequestType_Holder" + self.pyclass = Holder + + class UpdateScsiLunDisplayNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateScsiLunDisplayNameRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateScsiLunDisplayNameRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lunUuid"), aname="_lunUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"displayName"), aname="_displayName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._lunUuid = None + self._displayName = None + return + Holder.__name__ = "UpdateScsiLunDisplayNameRequestType_Holder" + self.pyclass = Holder + + class RefreshStorageSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RefreshStorageSystemRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RefreshStorageSystemRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RefreshStorageSystemRequestType_Holder" + self.pyclass = Holder + + class HostHardwareSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostHardwareSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostHardwareSummary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemIdentificationInfo",lazy=True)(pname=(ns,"otherIdentifyingInfo"), aname="_otherIdentifyingInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memorySize"), aname="_memorySize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cpuModel"), aname="_cpuModel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuMhz"), aname="_cpuMhz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuPkgs"), aname="_numCpuPkgs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuThreads"), aname="_numCpuThreads", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNics"), aname="_numNics", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numHBAs"), aname="_numHBAs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostHardwareSummary_Def.__bases__: + bases = list(ns0.HostHardwareSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostHardwareSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostListSummaryQuickStats_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostListSummaryQuickStats") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostListSummaryQuickStats_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"overallCpuUsage"), aname="_overallCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"overallMemoryUsage"), aname="_overallMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedCpuFairness"), aname="_distributedCpuFairness", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedMemoryFairness"), aname="_distributedMemoryFairness", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostListSummaryQuickStats_Def.__bases__: + bases = list(ns0.HostListSummaryQuickStats_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostListSummaryQuickStats_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostConfigSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostConfigSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostConfigSummary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AboutInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmotionEnabled"), aname="_vmotionEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"faultToleranceEnabled"), aname="_faultToleranceEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostConfigSummary_Def.__bases__: + bases = list(ns0.HostConfigSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostConfigSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostListSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostListSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostListSummary_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHardwareSummary",lazy=True)(pname=(ns,"hardware"), aname="_hardware", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostRuntimeInfo",lazy=True)(pname=(ns,"runtime"), aname="_runtime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSummary",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostListSummaryQuickStats",lazy=True)(pname=(ns,"quickStats"), aname="_quickStats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rebootRequired"), aname="_rebootRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomFieldValue",lazy=True)(pname=(ns,"customValue"), aname="_customValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"managementServerIp"), aname="_managementServerIp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"maxEVCModeKey"), aname="_maxEVCModeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostListSummary_Def.__bases__: + bases = list(ns0.HostListSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostListSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostSystemHealthInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSystemHealthInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSystemHealthInfo_Def.schema + TClist = [GTD("urn:vim25","HostNumericSensorInfo",lazy=True)(pname=(ns,"numericSensorInfo"), aname="_numericSensorInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSystemHealthInfo_Def.__bases__: + bases = list(ns0.HostSystemHealthInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSystemHealthInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostSystemIdentificationInfoIdentifier_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostSystemIdentificationInfoIdentifier") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostSystemIdentificationInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSystemIdentificationInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSystemIdentificationInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"identifierValue"), aname="_identifierValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"identifierType"), aname="_identifierType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSystemIdentificationInfo_Def.__bases__: + bases = list(ns0.HostSystemIdentificationInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSystemIdentificationInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostSystemIdentificationInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostSystemIdentificationInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostSystemIdentificationInfo_Def.schema + TClist = [GTD("urn:vim25","HostSystemIdentificationInfo",lazy=True)(pname=(ns,"HostSystemIdentificationInfo"), aname="_HostSystemIdentificationInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostSystemIdentificationInfo = [] + return + Holder.__name__ = "ArrayOfHostSystemIdentificationInfo_Holder" + self.pyclass = Holder + + class HostSystemResourceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostSystemResourceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostSystemResourceInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"child"), aname="_child", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostSystemResourceInfo_Def.__bases__: + bases = list(ns0.HostSystemResourceInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostSystemResourceInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostSystemResourceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostSystemResourceInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostSystemResourceInfo_Def.schema + TClist = [GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"HostSystemResourceInfo"), aname="_HostSystemResourceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostSystemResourceInfo = [] + return + Holder.__name__ = "ArrayOfHostSystemResourceInfo_Holder" + self.pyclass = Holder + + class HostTargetTransport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostTargetTransport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostTargetTransport_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostTargetTransport_Def.__bases__: + bases = list(ns0.HostTargetTransport_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostTargetTransport_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostParallelScsiTargetTransport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostParallelScsiTargetTransport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostParallelScsiTargetTransport_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostTargetTransport_Def not in ns0.HostParallelScsiTargetTransport_Def.__bases__: + bases = list(ns0.HostParallelScsiTargetTransport_Def.__bases__) + bases.insert(0, ns0.HostTargetTransport_Def) + ns0.HostParallelScsiTargetTransport_Def.__bases__ = tuple(bases) + + ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostBlockAdapterTargetTransport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostBlockAdapterTargetTransport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostBlockAdapterTargetTransport_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostTargetTransport_Def not in ns0.HostBlockAdapterTargetTransport_Def.__bases__: + bases = list(ns0.HostBlockAdapterTargetTransport_Def.__bases__) + bases.insert(0, ns0.HostTargetTransport_Def) + ns0.HostBlockAdapterTargetTransport_Def.__bases__ = tuple(bases) + + ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostFibreChannelTargetTransport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostFibreChannelTargetTransport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostFibreChannelTargetTransport_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"portWorldWideName"), aname="_portWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"nodeWorldWideName"), aname="_nodeWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostTargetTransport_Def not in ns0.HostFibreChannelTargetTransport_Def.__bases__: + bases = list(ns0.HostFibreChannelTargetTransport_Def.__bases__) + bases.insert(0, ns0.HostTargetTransport_Def) + ns0.HostFibreChannelTargetTransport_Def.__bases__ = tuple(bases) + + ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostInternetScsiTargetTransport_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostInternetScsiTargetTransport") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostInternetScsiTargetTransport_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiAlias"), aname="_iScsiAlias", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostTargetTransport_Def not in ns0.HostInternetScsiTargetTransport_Def.__bases__: + bases = list(ns0.HostInternetScsiTargetTransport_Def.__bases__) + bases.insert(0, ns0.HostTargetTransport_Def) + ns0.HostInternetScsiTargetTransport_Def.__bases__ = tuple(bases) + + ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDigestInfoDigestMethodType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostDigestInfoDigestMethodType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostDigestInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDigestInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDigestInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"digestMethod"), aname="_digestMethod", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"digestValue"), aname="_digestValue", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectName"), aname="_objectName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDigestInfo_Def.__bases__: + bases = list(ns0.HostDigestInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDigestInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostTpmDigestInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostTpmDigestInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostTpmDigestInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"pcrNumber"), aname="_pcrNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostDigestInfo_Def not in ns0.HostTpmDigestInfo_Def.__bases__: + bases = list(ns0.HostTpmDigestInfo_Def.__bases__) + bases.insert(0, ns0.HostDigestInfo_Def) + ns0.HostTpmDigestInfo_Def.__bases__ = tuple(bases) + + ns0.HostDigestInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostTpmDigestInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostTpmDigestInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostTpmDigestInfo_Def.schema + TClist = [GTD("urn:vim25","HostTpmDigestInfo",lazy=True)(pname=(ns,"HostTpmDigestInfo"), aname="_HostTpmDigestInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostTpmDigestInfo = [] + return + Holder.__name__ = "ArrayOfHostTpmDigestInfo_Holder" + self.pyclass = Holder + + class HostUnresolvedVmfsExtentUnresolvedReason_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsExtentUnresolvedReason") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostUnresolvedVmfsExtent_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsExtent") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUnresolvedVmfsExtent_Def.schema + TClist = [GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsUuid"), aname="_vmfsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"isHeadExtent"), aname="_isHeadExtent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ordinal"), aname="_ordinal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startBlock"), aname="_startBlock", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"endBlock"), aname="_endBlock", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsExtent_Def.__bases__: + bases = list(ns0.HostUnresolvedVmfsExtent_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostUnresolvedVmfsExtent_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostUnresolvedVmfsExtent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostUnresolvedVmfsExtent") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostUnresolvedVmfsExtent_Def.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsExtent",lazy=True)(pname=(ns,"HostUnresolvedVmfsExtent"), aname="_HostUnresolvedVmfsExtent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostUnresolvedVmfsExtent = [] + return + Holder.__name__ = "ArrayOfHostUnresolvedVmfsExtent_Holder" + self.pyclass = Holder + + class HostUnresolvedVmfsResignatureSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsResignatureSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUnresolvedVmfsResignatureSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"extentDevicePath"), aname="_extentDevicePath", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsResignatureSpec_Def.__bases__: + bases = list(ns0.HostUnresolvedVmfsResignatureSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostUnresolvedVmfsResignatureSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostUnresolvedVmfsResolutionResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsResolutionResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUnresolvedVmfsResolutionResult_Def.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVmfsVolume",lazy=True)(pname=(ns,"vmfs"), aname="_vmfs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsResolutionResult_Def.__bases__: + bases = list(ns0.HostUnresolvedVmfsResolutionResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostUnresolvedVmfsResolutionResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostUnresolvedVmfsResolutionResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostUnresolvedVmfsResolutionResult") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostUnresolvedVmfsResolutionResult_Def.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionResult",lazy=True)(pname=(ns,"HostUnresolvedVmfsResolutionResult"), aname="_HostUnresolvedVmfsResolutionResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostUnresolvedVmfsResolutionResult = [] + return + Holder.__name__ = "ArrayOfHostUnresolvedVmfsResolutionResult_Holder" + self.pyclass = Holder + + class HostUnresolvedVmfsResolutionSpecVmfsUuidResolution_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsResolutionSpecVmfsUuidResolution") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostUnresolvedVmfsResolutionSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsResolutionSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUnresolvedVmfsResolutionSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"extentDevicePath"), aname="_extentDevicePath", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuidResolution"), aname="_uuidResolution", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsResolutionSpec_Def.__bases__: + bases = list(ns0.HostUnresolvedVmfsResolutionSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostUnresolvedVmfsResolutionSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostUnresolvedVmfsResolutionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostUnresolvedVmfsResolutionSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostUnresolvedVmfsResolutionSpec_Def.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionSpec",lazy=True)(pname=(ns,"HostUnresolvedVmfsResolutionSpec"), aname="_HostUnresolvedVmfsResolutionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostUnresolvedVmfsResolutionSpec = [] + return + Holder.__name__ = "ArrayOfHostUnresolvedVmfsResolutionSpec_Holder" + self.pyclass = Holder + + class HostUnresolvedVmfsVolumeResolveStatus_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsVolumeResolveStatus") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"resolvable"), aname="_resolvable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"incompleteExtents"), aname="_incompleteExtents", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multipleCopies"), aname="_multipleCopies", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.__bases__: + bases = list(ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostUnresolvedVmfsVolume_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostUnresolvedVmfsVolume") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostUnresolvedVmfsVolume_Def.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsExtent",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsLabel"), aname="_vmfsLabel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsUuid"), aname="_vmfsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalBlocks"), aname="_totalBlocks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostUnresolvedVmfsVolumeResolveStatus",lazy=True)(pname=(ns,"resolveStatus"), aname="_resolveStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsVolume_Def.__bases__: + bases = list(ns0.HostUnresolvedVmfsVolume_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostUnresolvedVmfsVolume_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostUnresolvedVmfsVolume_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostUnresolvedVmfsVolume") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostUnresolvedVmfsVolume_Def.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsVolume",lazy=True)(pname=(ns,"HostUnresolvedVmfsVolume"), aname="_HostUnresolvedVmfsVolume", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostUnresolvedVmfsVolume = [] + return + Holder.__name__ = "ArrayOfHostUnresolvedVmfsVolume_Holder" + self.pyclass = Holder + + class HostVMotionConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVMotionConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVMotionConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vmotionNicKey"), aname="_vmotionNicKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVMotionConfig_Def.__bases__: + bases = list(ns0.HostVMotionConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVMotionConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVMotionInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVMotionInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVMotionInfo_Def.schema + TClist = [GTD("urn:vim25","HostVMotionNetConfig",lazy=True)(pname=(ns,"netConfig"), aname="_netConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVMotionInfo_Def.__bases__: + bases = list(ns0.HostVMotionInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVMotionInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVMotionNetConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVMotionNetConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVMotionNetConfig_Def.schema + TClist = [GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"candidateVnic"), aname="_candidateVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"selectedVnic"), aname="_selectedVnic", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVMotionNetConfig_Def.__bases__: + bases = list(ns0.HostVMotionNetConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVMotionNetConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpdateIpConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateIpConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateIpConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._ipConfig = None + return + Holder.__name__ = "UpdateIpConfigRequestType_Holder" + self.pyclass = Holder + + class SelectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "SelectVnicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.SelectVnicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._device = None + return + Holder.__name__ = "SelectVnicRequestType_Holder" + self.pyclass = Holder + + class DeselectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DeselectVnicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DeselectVnicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DeselectVnicRequestType_Holder" + self.pyclass = Holder + + class HostVirtualNicSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualNicSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualNicSpec_Def.schema + TClist = [GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"distributedVirtualPort"), aname="_distributedVirtualPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tsoEnabled"), aname="_tsoEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualNicSpec_Def.__bases__: + bases = list(ns0.HostVirtualNicSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualNicSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualNicConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualNicConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualNicConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualNicConfig_Def.__bases__: + bases = list(ns0.HostVirtualNicConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualNicConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostVirtualNicConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostVirtualNicConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostVirtualNicConfig_Def.schema + TClist = [GTD("urn:vim25","HostVirtualNicConfig",lazy=True)(pname=(ns,"HostVirtualNicConfig"), aname="_HostVirtualNicConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostVirtualNicConfig = [] + return + Holder.__name__ = "ArrayOfHostVirtualNicConfig_Holder" + self.pyclass = Holder + + class HostVirtualNic_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualNic") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualNic_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualNic_Def.__bases__: + bases = list(ns0.HostVirtualNic_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualNic_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostVirtualNic_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostVirtualNic") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostVirtualNic_Def.schema + TClist = [GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"HostVirtualNic"), aname="_HostVirtualNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostVirtualNic = [] + return + Holder.__name__ = "ArrayOfHostVirtualNic_Holder" + self.pyclass = Holder + + class HostVirtualNicConnection_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualNicConnection") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualNicConnection_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"dvPort"), aname="_dvPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualNicConnection_Def.__bases__: + bases = list(ns0.HostVirtualNicConnection_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualNicConnection_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualNicManagerNicType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostVirtualNicManagerNicType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class HostVirtualNicManagerNicTypeSelection_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualNicManagerNicTypeSelection") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualNicManagerNicTypeSelection_Def.schema + TClist = [GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualNicManagerNicTypeSelection_Def.__bases__: + bases = list(ns0.HostVirtualNicManagerNicTypeSelection_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualNicManagerNicTypeSelection_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostVirtualNicManagerNicTypeSelection_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostVirtualNicManagerNicTypeSelection") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostVirtualNicManagerNicTypeSelection_Def.schema + TClist = [GTD("urn:vim25","HostVirtualNicManagerNicTypeSelection",lazy=True)(pname=(ns,"HostVirtualNicManagerNicTypeSelection"), aname="_HostVirtualNicManagerNicTypeSelection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostVirtualNicManagerNicTypeSelection = [] + return + Holder.__name__ = "ArrayOfHostVirtualNicManagerNicTypeSelection_Holder" + self.pyclass = Holder + + class VirtualNicManagerNetConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualNicManagerNetConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualNicManagerNetConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multiSelectAllowed"), aname="_multiSelectAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"candidateVnic"), aname="_candidateVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"selectedVnic"), aname="_selectedVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualNicManagerNetConfig_Def.__bases__: + bases = list(ns0.VirtualNicManagerNetConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualNicManagerNetConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualNicManagerNetConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualNicManagerNetConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualNicManagerNetConfig_Def.schema + TClist = [GTD("urn:vim25","VirtualNicManagerNetConfig",lazy=True)(pname=(ns,"VirtualNicManagerNetConfig"), aname="_VirtualNicManagerNetConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualNicManagerNetConfig = [] + return + Holder.__name__ = "ArrayOfVirtualNicManagerNetConfig_Holder" + self.pyclass = Holder + + class QueryNetConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryNetConfigRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryNetConfigRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._nicType = None + return + Holder.__name__ = "QueryNetConfigRequestType_Holder" + self.pyclass = Holder + + class VirtualNicManagerSelectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualNicManagerSelectVnicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.VirtualNicManagerSelectVnicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._nicType = None + self._device = None + return + Holder.__name__ = "VirtualNicManagerSelectVnicRequestType_Holder" + self.pyclass = Holder + + class VirtualNicManagerDeselectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualNicManagerDeselectVnicRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.VirtualNicManagerDeselectVnicRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._nicType = None + self._device = None + return + Holder.__name__ = "VirtualNicManagerDeselectVnicRequestType_Holder" + self.pyclass = Holder + + class HostVirtualNicManagerInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualNicManagerInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualNicManagerInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualNicManagerNetConfig",lazy=True)(pname=(ns,"netConfig"), aname="_netConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualNicManagerInfo_Def.__bases__: + bases = list(ns0.HostVirtualNicManagerInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualNicManagerInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualSwitchBridge_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitchBridge") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitchBridge_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualSwitchBridge_Def.__bases__: + bases = list(ns0.HostVirtualSwitchBridge_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualSwitchBridge_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualSwitchAutoBridge_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitchAutoBridge") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitchAutoBridge_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"excludedNicDevice"), aname="_excludedNicDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostVirtualSwitchBridge_Def not in ns0.HostVirtualSwitchAutoBridge_Def.__bases__: + bases = list(ns0.HostVirtualSwitchAutoBridge_Def.__bases__) + bases.insert(0, ns0.HostVirtualSwitchBridge_Def) + ns0.HostVirtualSwitchAutoBridge_Def.__bases__ = tuple(bases) + + ns0.HostVirtualSwitchBridge_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualSwitchSimpleBridge_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitchSimpleBridge") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitchSimpleBridge_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"nicDevice"), aname="_nicDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostVirtualSwitchBridge_Def not in ns0.HostVirtualSwitchSimpleBridge_Def.__bases__: + bases = list(ns0.HostVirtualSwitchSimpleBridge_Def.__bases__) + bases.insert(0, ns0.HostVirtualSwitchBridge_Def) + ns0.HostVirtualSwitchSimpleBridge_Def.__bases__ = tuple(bases) + + ns0.HostVirtualSwitchBridge_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualSwitchBondBridge_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitchBondBridge") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitchBondBridge_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"nicDevice"), aname="_nicDevice", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchBeaconConfig",lazy=True)(pname=(ns,"beacon"), aname="_beacon", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkDiscoveryProtocolConfig",lazy=True)(pname=(ns,"linkDiscoveryProtocolConfig"), aname="_linkDiscoveryProtocolConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostVirtualSwitchBridge_Def not in ns0.HostVirtualSwitchBondBridge_Def.__bases__: + bases = list(ns0.HostVirtualSwitchBondBridge_Def.__bases__) + bases.insert(0, ns0.HostVirtualSwitchBridge_Def) + ns0.HostVirtualSwitchBondBridge_Def.__bases__ = tuple(bases) + + ns0.HostVirtualSwitchBridge_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualSwitchBeaconConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitchBeaconConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitchBeaconConfig_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualSwitchBeaconConfig_Def.__bases__: + bases = list(ns0.HostVirtualSwitchBeaconConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualSwitchBeaconConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualSwitchSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitchSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitchSpec_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchBridge",lazy=True)(pname=(ns,"bridge"), aname="_bridge", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualSwitchSpec_Def.__bases__: + bases = list(ns0.HostVirtualSwitchSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualSwitchSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVirtualSwitchConfig_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitchConfig") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitchConfig_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualSwitchConfig_Def.__bases__: + bases = list(ns0.HostVirtualSwitchConfig_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualSwitchConfig_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostVirtualSwitchConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostVirtualSwitchConfig") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostVirtualSwitchConfig_Def.schema + TClist = [GTD("urn:vim25","HostVirtualSwitchConfig",lazy=True)(pname=(ns,"HostVirtualSwitchConfig"), aname="_HostVirtualSwitchConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostVirtualSwitchConfig = [] + return + Holder.__name__ = "ArrayOfHostVirtualSwitchConfig_Holder" + self.pyclass = Holder + + class HostVirtualSwitch_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVirtualSwitch") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVirtualSwitch_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPortsAvailable"), aname="_numPortsAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVirtualSwitch_Def.__bases__: + bases = list(ns0.HostVirtualSwitch_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVirtualSwitch_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostVirtualSwitch_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostVirtualSwitch") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostVirtualSwitch_Def.schema + TClist = [GTD("urn:vim25","HostVirtualSwitch",lazy=True)(pname=(ns,"HostVirtualSwitch"), aname="_HostVirtualSwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostVirtualSwitch = [] + return + Holder.__name__ = "ArrayOfHostVirtualSwitch_Holder" + self.pyclass = Holder + + class HostVmfsRescanResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVmfsRescanResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVmfsRescanResult_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVmfsRescanResult_Def.__bases__: + bases = list(ns0.HostVmfsRescanResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVmfsRescanResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostVmfsRescanResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostVmfsRescanResult") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostVmfsRescanResult_Def.schema + TClist = [GTD("urn:vim25","HostVmfsRescanResult",lazy=True)(pname=(ns,"HostVmfsRescanResult"), aname="_HostVmfsRescanResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostVmfsRescanResult = [] + return + Holder.__name__ = "ArrayOfHostVmfsRescanResult_Holder" + self.pyclass = Holder + + class HostVmfsSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVmfsSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVmfsSpec_Def.schema + TClist = [GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"blockSizeMb"), aname="_blockSizeMb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"majorVersion"), aname="_majorVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"volumeName"), aname="_volumeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostVmfsSpec_Def.__bases__: + bases = list(ns0.HostVmfsSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostVmfsSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostVmfsVolume_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostVmfsVolume") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostVmfsVolume_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"blockSizeMb"), aname="_blockSizeMb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxBlocks"), aname="_maxBlocks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"majorVersion"), aname="_majorVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmfsUpgradable"), aname="_vmfsUpgradable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostForceMountedInfo",lazy=True)(pname=(ns,"forceMountedInfo"), aname="_forceMountedInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostFileSystemVolume_Def not in ns0.HostVmfsVolume_Def.__bases__: + bases = list(ns0.HostVmfsVolume_Def.__bases__) + bases.insert(0, ns0.HostFileSystemVolume_Def) + ns0.HostVmfsVolume_Def.__bases__ = tuple(bases) + + ns0.HostFileSystemVolume_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayUpdateOperation_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayUpdateOperation") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ArrayUpdateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ArrayUpdateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ArrayUpdateSpec_Def.schema + TClist = [GTD("urn:vim25","ArrayUpdateOperation",lazy=True)(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"removeKey"), aname="_removeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ArrayUpdateSpec_Def.__bases__: + bases = list(ns0.ArrayUpdateSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ArrayUpdateSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class BoolOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "BoolOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.BoolOption_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"supported"), aname="_supported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OptionType_Def not in ns0.BoolOption_Def.__bases__: + bases = list(ns0.BoolOption_Def.__bases__) + bases.insert(0, ns0.OptionType_Def) + ns0.BoolOption_Def.__bases__ = tuple(bases) + + ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ChoiceOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ChoiceOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ChoiceOption_Def.schema + TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"choiceInfo"), aname="_choiceInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultIndex"), aname="_defaultIndex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OptionType_Def not in ns0.ChoiceOption_Def.__bases__: + bases = list(ns0.ChoiceOption_Def.__bases__) + bases.insert(0, ns0.OptionType_Def) + ns0.ChoiceOption_Def.__bases__ = tuple(bases) + + ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FloatOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FloatOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FloatOption_Def.schema + TClist = [ZSI.TCnumbers.FPfloat(pname=(ns,"min"), aname="_min", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OptionType_Def not in ns0.FloatOption_Def.__bases__: + bases = list(ns0.FloatOption_Def.__bases__) + bases.insert(0, ns0.OptionType_Def) + ns0.FloatOption_Def.__bases__ = tuple(bases) + + ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IntOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IntOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IntOption_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"min"), aname="_min", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OptionType_Def not in ns0.IntOption_Def.__bases__: + bases = list(ns0.IntOption_Def.__bases__) + bases.insert(0, ns0.OptionType_Def) + ns0.IntOption_Def.__bases__ = tuple(bases) + + ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class LongOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LongOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LongOption_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"min"), aname="_min", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OptionType_Def not in ns0.LongOption_Def.__bases__: + bases = list(ns0.LongOption_Def.__bases__) + bases.insert(0, ns0.OptionType_Def) + ns0.LongOption_Def.__bases__ = tuple(bases) + + ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OptionDef_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OptionDef") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OptionDef_Def.schema + TClist = [GTD("urn:vim25","OptionType",lazy=True)(pname=(ns,"optionType"), aname="_optionType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ElementDescription_Def not in ns0.OptionDef_Def.__bases__: + bases = list(ns0.OptionDef_Def.__bases__) + bases.insert(0, ns0.ElementDescription_Def) + ns0.OptionDef_Def.__bases__ = tuple(bases) + + ns0.ElementDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOptionDef_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOptionDef") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOptionDef_Def.schema + TClist = [GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"OptionDef"), aname="_OptionDef", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OptionDef = [] + return + Holder.__name__ = "ArrayOfOptionDef_Holder" + self.pyclass = Holder + + class QueryOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + return + Holder.__name__ = "QueryOptionsRequestType_Holder" + self.pyclass = Holder + + class UpdateOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpdateOptionsRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.UpdateOptionsRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"changedValue"), aname="_changedValue", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._changedValue = [] + return + Holder.__name__ = "UpdateOptionsRequestType_Holder" + self.pyclass = Holder + + class OptionType_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OptionType") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OptionType_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"valueIsReadonly"), aname="_valueIsReadonly", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OptionType_Def.__bases__: + bases = list(ns0.OptionType_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OptionType_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OptionValue_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OptionValue") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OptionValue_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.OptionValue_Def.__bases__: + bases = list(ns0.OptionValue_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.OptionValue_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOptionValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOptionValue") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOptionValue_Def.schema + TClist = [GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"OptionValue"), aname="_OptionValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OptionValue = [] + return + Holder.__name__ = "ArrayOfOptionValue_Holder" + self.pyclass = Holder + + class StringOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "StringOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.StringOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"validCharacters"), aname="_validCharacters", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.OptionType_Def not in ns0.StringOption_Def.__bases__: + bases = list(ns0.StringOption_Def.__bases__) + bases.insert(0, ns0.OptionType_Def) + ns0.StringOption_Def.__bases__ = tuple(bases) + + ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ApplyProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ApplyProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ApplyProfile_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfilePolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ApplyProfile_Def.__bases__: + bases = list(ns0.ApplyProfile_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ApplyProfile_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ComplianceLocator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComplianceLocator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComplianceLocator_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"applyPath"), aname="_applyPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ComplianceLocator_Def.__bases__: + bases = list(ns0.ComplianceLocator_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ComplianceLocator_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfComplianceLocator_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfComplianceLocator") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfComplianceLocator_Def.schema + TClist = [GTD("urn:vim25","ComplianceLocator",lazy=True)(pname=(ns,"ComplianceLocator"), aname="_ComplianceLocator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ComplianceLocator = [] + return + Holder.__name__ = "ArrayOfComplianceLocator_Holder" + self.pyclass = Holder + + class ComplianceManagerCheckComplianceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ComplianceManagerCheckComplianceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ComplianceManagerCheckComplianceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._profile = [] + self._entity = [] + return + Holder.__name__ = "ComplianceManagerCheckComplianceRequestType_Holder" + self.pyclass = Holder + + class ComplianceManagerQueryComplianceStatusRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ComplianceManagerQueryComplianceStatusRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ComplianceManagerQueryComplianceStatusRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._profile = [] + self._entity = [] + return + Holder.__name__ = "ComplianceManagerQueryComplianceStatusRequestType_Holder" + self.pyclass = Holder + + class ComplianceManagerClearComplianceStatusRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ComplianceManagerClearComplianceStatusRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ComplianceManagerClearComplianceStatusRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._profile = [] + self._entity = [] + return + Holder.__name__ = "ComplianceManagerClearComplianceStatusRequestType_Holder" + self.pyclass = Holder + + class ComplianceManagerQueryExpressionMetadataRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ComplianceManagerQueryExpressionMetadataRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._expressionName = [] + return + Holder.__name__ = "ComplianceManagerQueryExpressionMetadataRequestType_Holder" + self.pyclass = Holder + + class ComplianceProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComplianceProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComplianceProfile_Def.schema + TClist = [GTD("urn:vim25","ProfileExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rootExpression"), aname="_rootExpression", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ComplianceProfile_Def.__bases__: + bases = list(ns0.ComplianceProfile_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ComplianceProfile_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ComplianceResultStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ComplianceResultStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ComplianceFailure_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComplianceFailure") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComplianceFailure_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"failureType"), aname="_failureType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ComplianceFailure_Def.__bases__: + bases = list(ns0.ComplianceFailure_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ComplianceFailure_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfComplianceFailure_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfComplianceFailure") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfComplianceFailure_Def.schema + TClist = [GTD("urn:vim25","ComplianceFailure",lazy=True)(pname=(ns,"ComplianceFailure"), aname="_ComplianceFailure", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ComplianceFailure = [] + return + Holder.__name__ = "ArrayOfComplianceFailure_Holder" + self.pyclass = Holder + + class ComplianceResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ComplianceResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ComplianceResult_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"complianceStatus"), aname="_complianceStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"checkTime"), aname="_checkTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceFailure",lazy=True)(pname=(ns,"failure"), aname="_failure", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ComplianceResult_Def.__bases__: + bases = list(ns0.ComplianceResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ComplianceResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfComplianceResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfComplianceResult") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfComplianceResult_Def.schema + TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"ComplianceResult"), aname="_ComplianceResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ComplianceResult = [] + return + Holder.__name__ = "ArrayOfComplianceResult_Holder" + self.pyclass = Holder + + class ProfileDeferredPolicyOptionParameter_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileDeferredPolicyOptionParameter") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileDeferredPolicyOptionParameter_Def.schema + TClist = [GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"inputPath"), aname="_inputPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileDeferredPolicyOptionParameter_Def.__bases__: + bases = list(ns0.ProfileDeferredPolicyOptionParameter_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileDeferredPolicyOptionParameter_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileDeferredPolicyOptionParameter_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileDeferredPolicyOptionParameter") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileDeferredPolicyOptionParameter_Def.schema + TClist = [GTD("urn:vim25","ProfileDeferredPolicyOptionParameter",lazy=True)(pname=(ns,"ProfileDeferredPolicyOptionParameter"), aname="_ProfileDeferredPolicyOptionParameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileDeferredPolicyOptionParameter = [] + return + Holder.__name__ = "ArrayOfProfileDeferredPolicyOptionParameter_Holder" + self.pyclass = Holder + + class ProfileExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileExpression_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"displayName"), aname="_displayName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"negated"), aname="_negated", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileExpression_Def.__bases__: + bases = list(ns0.ProfileExpression_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileExpression_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileExpression_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileExpression") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileExpression_Def.schema + TClist = [GTD("urn:vim25","ProfileExpression",lazy=True)(pname=(ns,"ProfileExpression"), aname="_ProfileExpression", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileExpression = [] + return + Holder.__name__ = "ArrayOfProfileExpression_Holder" + self.pyclass = Holder + + class ProfileSimpleExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileSimpleExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileSimpleExpression_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"expressionType"), aname="_expressionType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileExpression_Def not in ns0.ProfileSimpleExpression_Def.__bases__: + bases = list(ns0.ProfileSimpleExpression_Def.__bases__) + bases.insert(0, ns0.ProfileExpression_Def) + ns0.ProfileSimpleExpression_Def.__bases__ = tuple(bases) + + ns0.ProfileExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileCompositeExpression_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileCompositeExpression") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileCompositeExpression_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileExpression_Def not in ns0.ProfileCompositeExpression_Def.__bases__: + bases = list(ns0.ProfileCompositeExpression_Def.__bases__) + bases.insert(0, ns0.ProfileExpression_Def) + ns0.ProfileCompositeExpression_Def.__bases__ = tuple(bases) + + ns0.ProfileExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileExpressionMetadata_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileExpressionMetadata") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileExpressionMetadata_Def.schema + TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"expressionId"), aname="_expressionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileExpressionMetadata_Def.__bases__: + bases = list(ns0.ProfileExpressionMetadata_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileExpressionMetadata_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileExpressionMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileExpressionMetadata") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileExpressionMetadata_Def.schema + TClist = [GTD("urn:vim25","ProfileExpressionMetadata",lazy=True)(pname=(ns,"ProfileExpressionMetadata"), aname="_ProfileExpressionMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileExpressionMetadata = [] + return + Holder.__name__ = "ArrayOfProfileExpressionMetadata_Holder" + self.pyclass = Holder + + class ProfileNumericComparator_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileNumericComparator") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ProfileParameterMetadata_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileParameterMetadata") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileParameterMetadata_Def.schema + TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"optional"), aname="_optional", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileParameterMetadata_Def.__bases__: + bases = list(ns0.ProfileParameterMetadata_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileParameterMetadata_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileParameterMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileParameterMetadata") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileParameterMetadata_Def.schema + TClist = [GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"ProfileParameterMetadata"), aname="_ProfileParameterMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileParameterMetadata = [] + return + Holder.__name__ = "ArrayOfProfileParameterMetadata_Holder" + self.pyclass = Holder + + class ProfilePolicy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfilePolicy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfilePolicy_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PolicyOption",lazy=True)(pname=(ns,"policyOption"), aname="_policyOption", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfilePolicy_Def.__bases__: + bases = list(ns0.ProfilePolicy_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfilePolicy_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfilePolicy_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfilePolicy") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfilePolicy_Def.schema + TClist = [GTD("urn:vim25","ProfilePolicy",lazy=True)(pname=(ns,"ProfilePolicy"), aname="_ProfilePolicy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfilePolicy = [] + return + Holder.__name__ = "ArrayOfProfilePolicy_Holder" + self.pyclass = Holder + + class ProfilePolicyOptionMetadata_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfilePolicyOptionMetadata") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfilePolicyOptionMetadata_Def.schema + TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfilePolicyOptionMetadata_Def.__bases__: + bases = list(ns0.ProfilePolicyOptionMetadata_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfilePolicyOptionMetadata_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfilePolicyOptionMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfilePolicyOptionMetadata") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfilePolicyOptionMetadata_Def.schema + TClist = [GTD("urn:vim25","ProfilePolicyOptionMetadata",lazy=True)(pname=(ns,"ProfilePolicyOptionMetadata"), aname="_ProfilePolicyOptionMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfilePolicyOptionMetadata = [] + return + Holder.__name__ = "ArrayOfProfilePolicyOptionMetadata_Holder" + self.pyclass = Holder + + class ProfileCompositePolicyOptionMetadata_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileCompositePolicyOptionMetadata") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileCompositePolicyOptionMetadata_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"option"), aname="_option", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfilePolicyOptionMetadata_Def not in ns0.ProfileCompositePolicyOptionMetadata_Def.__bases__: + bases = list(ns0.ProfileCompositePolicyOptionMetadata_Def.__bases__) + bases.insert(0, ns0.ProfilePolicyOptionMetadata_Def) + ns0.ProfileCompositePolicyOptionMetadata_Def.__bases__ = tuple(bases) + + ns0.ProfilePolicyOptionMetadata_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserInputRequiredParameterMetadata_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserInputRequiredParameterMetadata") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserInputRequiredParameterMetadata_Def.schema + TClist = [GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"userInputParameter"), aname="_userInputParameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfilePolicyOptionMetadata_Def not in ns0.UserInputRequiredParameterMetadata_Def.__bases__: + bases = list(ns0.UserInputRequiredParameterMetadata_Def.__bases__) + bases.insert(0, ns0.ProfilePolicyOptionMetadata_Def) + ns0.UserInputRequiredParameterMetadata_Def.__bases__ = tuple(bases) + + ns0.ProfilePolicyOptionMetadata_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfilePolicyMetadata_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfilePolicyMetadata") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfilePolicyMetadata_Def.schema + TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfilePolicyOptionMetadata",lazy=True)(pname=(ns,"possibleOption"), aname="_possibleOption", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfilePolicyMetadata_Def.__bases__: + bases = list(ns0.ProfilePolicyMetadata_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfilePolicyMetadata_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfilePolicyMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfilePolicyMetadata") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfilePolicyMetadata_Def.schema + TClist = [GTD("urn:vim25","ProfilePolicyMetadata",lazy=True)(pname=(ns,"ProfilePolicyMetadata"), aname="_ProfilePolicyMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfilePolicyMetadata = [] + return + Holder.__name__ = "ArrayOfProfilePolicyMetadata_Holder" + self.pyclass = Holder + + class PolicyOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PolicyOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PolicyOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.PolicyOption_Def.__bases__: + bases = list(ns0.PolicyOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.PolicyOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPolicyOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPolicyOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPolicyOption_Def.schema + TClist = [GTD("urn:vim25","PolicyOption",lazy=True)(pname=(ns,"PolicyOption"), aname="_PolicyOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PolicyOption = [] + return + Holder.__name__ = "ArrayOfPolicyOption_Holder" + self.pyclass = Holder + + class CompositePolicyOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CompositePolicyOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CompositePolicyOption_Def.schema + TClist = [GTD("urn:vim25","PolicyOption",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PolicyOption_Def not in ns0.CompositePolicyOption_Def.__bases__: + bases = list(ns0.CompositePolicyOption_Def.__bases__) + bases.insert(0, ns0.PolicyOption_Def) + ns0.CompositePolicyOption_Def.__bases__ = tuple(bases) + + ns0.PolicyOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileCreateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileCreateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileCreateSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileCreateSpec_Def.__bases__: + bases = list(ns0.ProfileCreateSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileCreateSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileSerializedCreateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileSerializedCreateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileSerializedCreateSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"profileConfigString"), aname="_profileConfigString", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileCreateSpec_Def not in ns0.ProfileSerializedCreateSpec_Def.__bases__: + bases = list(ns0.ProfileSerializedCreateSpec_Def.__bases__) + bases.insert(0, ns0.ProfileCreateSpec_Def) + ns0.ProfileSerializedCreateSpec_Def.__bases__ = tuple(bases) + + ns0.ProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileConfigInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileConfigInfo_Def.__bases__: + bases = list(ns0.ProfileConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileDescriptionSection_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileDescriptionSection") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileDescriptionSection_Def.schema + TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileDescriptionSection_Def.__bases__: + bases = list(ns0.ProfileDescriptionSection_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileDescriptionSection_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileDescriptionSection_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileDescriptionSection") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileDescriptionSection_Def.schema + TClist = [GTD("urn:vim25","ProfileDescriptionSection",lazy=True)(pname=(ns,"ProfileDescriptionSection"), aname="_ProfileDescriptionSection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileDescriptionSection = [] + return + Holder.__name__ = "ArrayOfProfileDescriptionSection_Holder" + self.pyclass = Holder + + class ProfileDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileDescription_Def.schema + TClist = [GTD("urn:vim25","ProfileDescriptionSection",lazy=True)(pname=(ns,"section"), aname="_section", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileDescription_Def.__bases__: + bases = list(ns0.ProfileDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ProfileDestroyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileDestroyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ProfileDestroyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ProfileDestroyRequestType_Holder" + self.pyclass = Holder + + class ProfileAssociateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileAssociateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ProfileAssociateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = [] + return + Holder.__name__ = "ProfileAssociateRequestType_Holder" + self.pyclass = Holder + + class ProfileDissociateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileDissociateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ProfileDissociateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = [] + return + Holder.__name__ = "ProfileDissociateRequestType_Holder" + self.pyclass = Holder + + class ProfileCheckComplianceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileCheckComplianceRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ProfileCheckComplianceRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = [] + return + Holder.__name__ = "ProfileCheckComplianceRequestType_Holder" + self.pyclass = Holder + + class ProfileExportProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileExportProfileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ProfileExportProfileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "ProfileExportProfileRequestType_Holder" + self.pyclass = Holder + + class CreateProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateProfileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateProfileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileCreateSpec",lazy=True)(pname=(ns,"createSpec"), aname="_createSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._createSpec = None + return + Holder.__name__ = "CreateProfileRequestType_Holder" + self.pyclass = Holder + + class ProfileQueryPolicyMetadataRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileQueryPolicyMetadataRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ProfileQueryPolicyMetadataRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policyName"), aname="_policyName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._policyName = [] + return + Holder.__name__ = "ProfileQueryPolicyMetadataRequestType_Holder" + self.pyclass = Holder + + class ProfileFindAssociatedProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileFindAssociatedProfileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ProfileFindAssociatedProfileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + return + Holder.__name__ = "ProfileFindAssociatedProfileRequestType_Holder" + self.pyclass = Holder + + class ProfileMetadata_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileMetadata") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileMetadata_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtendedDescription",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileMetadata_Def.__bases__: + bases = list(ns0.ProfileMetadata_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileMetadata_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileMetadata") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileMetadata_Def.schema + TClist = [GTD("urn:vim25","ProfileMetadata",lazy=True)(pname=(ns,"ProfileMetadata"), aname="_ProfileMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileMetadata = [] + return + Holder.__name__ = "ArrayOfProfileMetadata_Holder" + self.pyclass = Holder + + class ProfilePropertyPath_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfilePropertyPath") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfilePropertyPath_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"profilePath"), aname="_profilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policyId"), aname="_policyId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfilePropertyPath_Def.__bases__: + bases = list(ns0.ProfilePropertyPath_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfilePropertyPath_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterProfileConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterProfileConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterProfileConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"complyProfile"), aname="_complyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileConfigInfo_Def not in ns0.ClusterProfileConfigInfo_Def.__bases__: + bases = list(ns0.ClusterProfileConfigInfo_Def.__bases__) + bases.insert(0, ns0.ProfileConfigInfo_Def) + ns0.ClusterProfileConfigInfo_Def.__bases__ = tuple(bases) + + ns0.ProfileConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterProfileCreateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterProfileCreateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterProfileCreateSpec_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileCreateSpec_Def not in ns0.ClusterProfileCreateSpec_Def.__bases__: + bases = list(ns0.ClusterProfileCreateSpec_Def.__bases__) + bases.insert(0, ns0.ProfileCreateSpec_Def) + ns0.ClusterProfileCreateSpec_Def.__bases__ = tuple(bases) + + ns0.ProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterProfileConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterProfileConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterProfileConfigSpec_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterProfileCreateSpec_Def not in ns0.ClusterProfileConfigSpec_Def.__bases__: + bases = list(ns0.ClusterProfileConfigSpec_Def.__bases__) + bases.insert(0, ns0.ClusterProfileCreateSpec_Def) + ns0.ClusterProfileConfigSpec_Def.__bases__ = tuple(bases) + + ns0.ClusterProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterProfileCompleteConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterProfileCompleteConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterProfileCompleteConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"complyProfile"), aname="_complyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterProfileConfigSpec_Def not in ns0.ClusterProfileCompleteConfigSpec_Def.__bases__: + bases = list(ns0.ClusterProfileCompleteConfigSpec_Def.__bases__) + bases.insert(0, ns0.ClusterProfileConfigSpec_Def) + ns0.ClusterProfileCompleteConfigSpec_Def.__bases__ = tuple(bases) + + ns0.ClusterProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterProfileServiceType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ClusterProfileServiceType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ClusterProfileConfigServiceCreateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ClusterProfileConfigServiceCreateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ClusterProfileConfigServiceCreateSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"serviceType"), aname="_serviceType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ClusterProfileConfigSpec_Def not in ns0.ClusterProfileConfigServiceCreateSpec_Def.__bases__: + bases = list(ns0.ClusterProfileConfigServiceCreateSpec_Def.__bases__) + bases.insert(0, ns0.ClusterProfileConfigSpec_Def) + ns0.ClusterProfileConfigServiceCreateSpec_Def.__bases__ = tuple(bases) + + ns0.ClusterProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ClusterProfileUpdateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ClusterProfileUpdateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ClusterProfileUpdateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterProfileConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + return + Holder.__name__ = "ClusterProfileUpdateRequestType_Holder" + self.pyclass = Holder + + class ProfileExecuteResultStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ProfileExecuteResultStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ProfileExecuteError_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileExecuteError") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileExecuteError_Def.schema + TClist = [GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileExecuteError_Def.__bases__: + bases = list(ns0.ProfileExecuteError_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileExecuteError_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfProfileExecuteError_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfProfileExecuteError") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfProfileExecuteError_Def.schema + TClist = [GTD("urn:vim25","ProfileExecuteError",lazy=True)(pname=(ns,"ProfileExecuteError"), aname="_ProfileExecuteError", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ProfileExecuteError = [] + return + Holder.__name__ = "ArrayOfProfileExecuteError_Holder" + self.pyclass = Holder + + class ProfileExecuteResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ProfileExecuteResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ProfileExecuteResult_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"inapplicablePath"), aname="_inapplicablePath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileDeferredPolicyOptionParameter",lazy=True)(pname=(ns,"requireInput"), aname="_requireInput", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileExecuteError",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ProfileExecuteResult_Def.__bases__: + bases = list(ns0.ProfileExecuteResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ProfileExecuteResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostApplyProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostApplyProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostApplyProfile_Def.schema + TClist = [GTD("urn:vim25","HostMemoryProfile",lazy=True)(pname=(ns,"memory"), aname="_memory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","StorageProfile",lazy=True)(pname=(ns,"storage"), aname="_storage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkProfile",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DateTimeProfile",lazy=True)(pname=(ns,"datetime"), aname="_datetime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FirewallProfile",lazy=True)(pname=(ns,"firewall"), aname="_firewall", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SecurityProfile",lazy=True)(pname=(ns,"security"), aname="_security", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ServiceProfile",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionProfile",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","UserProfile",lazy=True)(pname=(ns,"userAccount"), aname="_userAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","UserGroupProfile",lazy=True)(pname=(ns,"usergroupAccount"), aname="_usergroupAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.HostApplyProfile_Def.__bases__: + bases = list(ns0.HostApplyProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.HostApplyProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PhysicalNicProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PhysicalNicProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PhysicalNicProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.PhysicalNicProfile_Def.__bases__: + bases = list(ns0.PhysicalNicProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.PhysicalNicProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPhysicalNicProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPhysicalNicProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPhysicalNicProfile_Def.schema + TClist = [GTD("urn:vim25","PhysicalNicProfile",lazy=True)(pname=(ns,"PhysicalNicProfile"), aname="_PhysicalNicProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PhysicalNicProfile = [] + return + Holder.__name__ = "ArrayOfPhysicalNicProfile_Holder" + self.pyclass = Holder + + class HostMemoryProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostMemoryProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostMemoryProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.HostMemoryProfile_Def.__bases__: + bases = list(ns0.HostMemoryProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.HostMemoryProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UserProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.UserProfile_Def.__bases__: + bases = list(ns0.UserProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.UserProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfUserProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfUserProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfUserProfile_Def.schema + TClist = [GTD("urn:vim25","UserProfile",lazy=True)(pname=(ns,"UserProfile"), aname="_UserProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._UserProfile = [] + return + Holder.__name__ = "ArrayOfUserProfile_Holder" + self.pyclass = Holder + + class UserGroupProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "UserGroupProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.UserGroupProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.UserGroupProfile_Def.__bases__: + bases = list(ns0.UserGroupProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.UserGroupProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfUserGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfUserGroupProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfUserGroupProfile_Def.schema + TClist = [GTD("urn:vim25","UserGroupProfile",lazy=True)(pname=(ns,"UserGroupProfile"), aname="_UserGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._UserGroupProfile = [] + return + Holder.__name__ = "ArrayOfUserGroupProfile_Holder" + self.pyclass = Holder + + class SecurityProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "SecurityProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.SecurityProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.SecurityProfile_Def.__bases__: + bases = list(ns0.SecurityProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.SecurityProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OptionProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OptionProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OptionProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.OptionProfile_Def.__bases__: + bases = list(ns0.OptionProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.OptionProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfOptionProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfOptionProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfOptionProfile_Def.schema + TClist = [GTD("urn:vim25","OptionProfile",lazy=True)(pname=(ns,"OptionProfile"), aname="_OptionProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._OptionProfile = [] + return + Holder.__name__ = "ArrayOfOptionProfile_Holder" + self.pyclass = Holder + + class DateTimeProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DateTimeProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DateTimeProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.DateTimeProfile_Def.__bases__: + bases = list(ns0.DateTimeProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.DateTimeProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ServiceProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ServiceProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ServiceProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.ServiceProfile_Def.__bases__: + bases = list(ns0.ServiceProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.ServiceProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfServiceProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfServiceProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfServiceProfile_Def.schema + TClist = [GTD("urn:vim25","ServiceProfile",lazy=True)(pname=(ns,"ServiceProfile"), aname="_ServiceProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ServiceProfile = [] + return + Holder.__name__ = "ArrayOfServiceProfile_Holder" + self.pyclass = Holder + + class FirewallProfileRulesetProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FirewallProfileRulesetProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FirewallProfileRulesetProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.FirewallProfileRulesetProfile_Def.__bases__: + bases = list(ns0.FirewallProfileRulesetProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.FirewallProfileRulesetProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfFirewallProfileRulesetProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfFirewallProfileRulesetProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfFirewallProfileRulesetProfile_Def.schema + TClist = [GTD("urn:vim25","FirewallProfileRulesetProfile",lazy=True)(pname=(ns,"FirewallProfileRulesetProfile"), aname="_FirewallProfileRulesetProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._FirewallProfileRulesetProfile = [] + return + Holder.__name__ = "ArrayOfFirewallProfileRulesetProfile_Holder" + self.pyclass = Holder + + class FirewallProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FirewallProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FirewallProfile_Def.schema + TClist = [GTD("urn:vim25","FirewallProfileRulesetProfile",lazy=True)(pname=(ns,"ruleset"), aname="_ruleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.FirewallProfile_Def.__bases__: + bases = list(ns0.FirewallProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.FirewallProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NasStorageProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NasStorageProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NasStorageProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.NasStorageProfile_Def.__bases__: + bases = list(ns0.NasStorageProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.NasStorageProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfNasStorageProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfNasStorageProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfNasStorageProfile_Def.schema + TClist = [GTD("urn:vim25","NasStorageProfile",lazy=True)(pname=(ns,"NasStorageProfile"), aname="_NasStorageProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._NasStorageProfile = [] + return + Holder.__name__ = "ArrayOfNasStorageProfile_Holder" + self.pyclass = Holder + + class StorageProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "StorageProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.StorageProfile_Def.schema + TClist = [GTD("urn:vim25","NasStorageProfile",lazy=True)(pname=(ns,"nasStorage"), aname="_nasStorage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.StorageProfile_Def.__bases__: + bases = list(ns0.StorageProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.StorageProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NetworkProfileDnsConfigProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworkProfileDnsConfigProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworkProfileDnsConfigProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.NetworkProfileDnsConfigProfile_Def.__bases__: + bases = list(ns0.NetworkProfileDnsConfigProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.NetworkProfileDnsConfigProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NetworkProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworkProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworkProfile_Def.schema + TClist = [GTD("urn:vim25","VirtualSwitchProfile",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmPortGroupProfile",lazy=True)(pname=(ns,"vmPortGroup"), aname="_vmPortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupProfile",lazy=True)(pname=(ns,"hostPortGroup"), aname="_hostPortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ServiceConsolePortGroupProfile",lazy=True)(pname=(ns,"serviceConsolePortGroup"), aname="_serviceConsolePortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkProfileDnsConfigProfile",lazy=True)(pname=(ns,"dnsConfig"), aname="_dnsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpRouteProfile",lazy=True)(pname=(ns,"ipRouteConfig"), aname="_ipRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpRouteProfile",lazy=True)(pname=(ns,"consoleIpRouteConfig"), aname="_consoleIpRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicProfile",lazy=True)(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsProfile",lazy=True)(pname=(ns,"dvswitch"), aname="_dvswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsServiceConsoleVNicProfile",lazy=True)(pname=(ns,"dvsServiceConsoleNic"), aname="_dvsServiceConsoleNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsHostVNicProfile",lazy=True)(pname=(ns,"dvsHostNic"), aname="_dvsHostNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.NetworkProfile_Def.__bases__: + bases = list(ns0.NetworkProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.NetworkProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsVNicProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsVNicProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsVNicProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpAddressProfile",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.DvsVNicProfile_Def.__bases__: + bases = list(ns0.DvsVNicProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.DvsVNicProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DvsServiceConsoleVNicProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsServiceConsoleVNicProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsServiceConsoleVNicProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsVNicProfile_Def not in ns0.DvsServiceConsoleVNicProfile_Def.__bases__: + bases = list(ns0.DvsServiceConsoleVNicProfile_Def.__bases__) + bases.insert(0, ns0.DvsVNicProfile_Def) + ns0.DvsServiceConsoleVNicProfile_Def.__bases__ = tuple(bases) + + ns0.DvsVNicProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDvsServiceConsoleVNicProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDvsServiceConsoleVNicProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDvsServiceConsoleVNicProfile_Def.schema + TClist = [GTD("urn:vim25","DvsServiceConsoleVNicProfile",lazy=True)(pname=(ns,"DvsServiceConsoleVNicProfile"), aname="_DvsServiceConsoleVNicProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DvsServiceConsoleVNicProfile = [] + return + Holder.__name__ = "ArrayOfDvsServiceConsoleVNicProfile_Holder" + self.pyclass = Holder + + class DvsHostVNicProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsHostVNicProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsHostVNicProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DvsVNicProfile_Def not in ns0.DvsHostVNicProfile_Def.__bases__: + bases = list(ns0.DvsHostVNicProfile_Def.__bases__) + bases.insert(0, ns0.DvsVNicProfile_Def) + ns0.DvsHostVNicProfile_Def.__bases__ = tuple(bases) + + ns0.DvsVNicProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDvsHostVNicProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDvsHostVNicProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDvsHostVNicProfile_Def.schema + TClist = [GTD("urn:vim25","DvsHostVNicProfile",lazy=True)(pname=(ns,"DvsHostVNicProfile"), aname="_DvsHostVNicProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DvsHostVNicProfile = [] + return + Holder.__name__ = "ArrayOfDvsHostVNicProfile_Holder" + self.pyclass = Holder + + class DvsProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DvsProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DvsProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PnicUplinkProfile",lazy=True)(pname=(ns,"uplink"), aname="_uplink", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.DvsProfile_Def.__bases__: + bases = list(ns0.DvsProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.DvsProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfDvsProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfDvsProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfDvsProfile_Def.schema + TClist = [GTD("urn:vim25","DvsProfile",lazy=True)(pname=(ns,"DvsProfile"), aname="_DvsProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._DvsProfile = [] + return + Holder.__name__ = "ArrayOfDvsProfile_Holder" + self.pyclass = Holder + + class PnicUplinkProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PnicUplinkProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PnicUplinkProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.PnicUplinkProfile_Def.__bases__: + bases = list(ns0.PnicUplinkProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.PnicUplinkProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfPnicUplinkProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfPnicUplinkProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfPnicUplinkProfile_Def.schema + TClist = [GTD("urn:vim25","PnicUplinkProfile",lazy=True)(pname=(ns,"PnicUplinkProfile"), aname="_PnicUplinkProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._PnicUplinkProfile = [] + return + Holder.__name__ = "ArrayOfPnicUplinkProfile_Holder" + self.pyclass = Holder + + class IpRouteProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IpRouteProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IpRouteProfile_Def.schema + TClist = [GTD("urn:vim25","StaticRouteProfile",lazy=True)(pname=(ns,"staticRoute"), aname="_staticRoute", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.IpRouteProfile_Def.__bases__: + bases = list(ns0.IpRouteProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.IpRouteProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class StaticRouteProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "StaticRouteProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.StaticRouteProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.StaticRouteProfile_Def.__bases__: + bases = list(ns0.StaticRouteProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.StaticRouteProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfStaticRouteProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfStaticRouteProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfStaticRouteProfile_Def.schema + TClist = [GTD("urn:vim25","StaticRouteProfile",lazy=True)(pname=(ns,"StaticRouteProfile"), aname="_StaticRouteProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._StaticRouteProfile = [] + return + Holder.__name__ = "ArrayOfStaticRouteProfile_Holder" + self.pyclass = Holder + + class LinkProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "LinkProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.LinkProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.LinkProfile_Def.__bases__: + bases = list(ns0.LinkProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.LinkProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class NumPortsProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NumPortsProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NumPortsProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.NumPortsProfile_Def.__bases__: + bases = list(ns0.NumPortsProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.NumPortsProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSwitchProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSwitchProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSwitchProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkProfile",lazy=True)(pname=(ns,"link"), aname="_link", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NumPortsProfile",lazy=True)(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkPolicyProfile",lazy=True)(pname=(ns,"networkPolicy"), aname="_networkPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.VirtualSwitchProfile_Def.__bases__: + bases = list(ns0.VirtualSwitchProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.VirtualSwitchProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualSwitchProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualSwitchProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualSwitchProfile_Def.schema + TClist = [GTD("urn:vim25","VirtualSwitchProfile",lazy=True)(pname=(ns,"VirtualSwitchProfile"), aname="_VirtualSwitchProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualSwitchProfile = [] + return + Holder.__name__ = "ArrayOfVirtualSwitchProfile_Holder" + self.pyclass = Holder + + class VlanProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VlanProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VlanProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.VlanProfile_Def.__bases__: + bases = list(ns0.VlanProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.VlanProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSwitchSelectionProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSwitchSelectionProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSwitchSelectionProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.VirtualSwitchSelectionProfile_Def.__bases__: + bases = list(ns0.VirtualSwitchSelectionProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.VirtualSwitchSelectionProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class PortGroupProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "PortGroupProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.PortGroupProfile_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VlanProfile",lazy=True)(pname=(ns,"vlan"), aname="_vlan", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualSwitchSelectionProfile",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkPolicyProfile",lazy=True)(pname=(ns,"networkPolicy"), aname="_networkPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.PortGroupProfile_Def.__bases__: + bases = list(ns0.PortGroupProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.PortGroupProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmPortGroupProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmPortGroupProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmPortGroupProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PortGroupProfile_Def not in ns0.VmPortGroupProfile_Def.__bases__: + bases = list(ns0.VmPortGroupProfile_Def.__bases__) + bases.insert(0, ns0.PortGroupProfile_Def) + ns0.VmPortGroupProfile_Def.__bases__ = tuple(bases) + + ns0.PortGroupProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVmPortGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVmPortGroupProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVmPortGroupProfile_Def.schema + TClist = [GTD("urn:vim25","VmPortGroupProfile",lazy=True)(pname=(ns,"VmPortGroupProfile"), aname="_VmPortGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VmPortGroupProfile = [] + return + Holder.__name__ = "ArrayOfVmPortGroupProfile_Holder" + self.pyclass = Holder + + class HostPortGroupProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostPortGroupProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostPortGroupProfile_Def.schema + TClist = [GTD("urn:vim25","IpAddressProfile",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PortGroupProfile_Def not in ns0.HostPortGroupProfile_Def.__bases__: + bases = list(ns0.HostPortGroupProfile_Def.__bases__) + bases.insert(0, ns0.PortGroupProfile_Def) + ns0.HostPortGroupProfile_Def.__bases__ = tuple(bases) + + ns0.PortGroupProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostPortGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostPortGroupProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostPortGroupProfile_Def.schema + TClist = [GTD("urn:vim25","HostPortGroupProfile",lazy=True)(pname=(ns,"HostPortGroupProfile"), aname="_HostPortGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostPortGroupProfile = [] + return + Holder.__name__ = "ArrayOfHostPortGroupProfile_Holder" + self.pyclass = Holder + + class ServiceConsolePortGroupProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ServiceConsolePortGroupProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ServiceConsolePortGroupProfile_Def.schema + TClist = [GTD("urn:vim25","IpAddressProfile",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.PortGroupProfile_Def not in ns0.ServiceConsolePortGroupProfile_Def.__bases__: + bases = list(ns0.ServiceConsolePortGroupProfile_Def.__bases__) + bases.insert(0, ns0.PortGroupProfile_Def) + ns0.ServiceConsolePortGroupProfile_Def.__bases__ = tuple(bases) + + ns0.PortGroupProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfServiceConsolePortGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfServiceConsolePortGroupProfile") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfServiceConsolePortGroupProfile_Def.schema + TClist = [GTD("urn:vim25","ServiceConsolePortGroupProfile",lazy=True)(pname=(ns,"ServiceConsolePortGroupProfile"), aname="_ServiceConsolePortGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ServiceConsolePortGroupProfile = [] + return + Holder.__name__ = "ArrayOfServiceConsolePortGroupProfile_Holder" + self.pyclass = Holder + + class NetworkPolicyProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "NetworkPolicyProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.NetworkPolicyProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.NetworkPolicyProfile_Def.__bases__: + bases = list(ns0.NetworkPolicyProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.NetworkPolicyProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IpAddressProfile_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IpAddressProfile") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IpAddressProfile_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ApplyProfile_Def not in ns0.IpAddressProfile_Def.__bases__: + bases = list(ns0.IpAddressProfile_Def.__bases__) + bases.insert(0, ns0.ApplyProfile_Def) + ns0.IpAddressProfile_Def.__bases__ = tuple(bases) + + ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProfileConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProfileConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProfileConfigInfo_Def.schema + TClist = [GTD("urn:vim25","HostApplyProfile",lazy=True)(pname=(ns,"applyProfile"), aname="_applyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"defaultComplyProfile"), aname="_defaultComplyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceLocator",lazy=True)(pname=(ns,"defaultComplyLocator"), aname="_defaultComplyLocator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"customComplyProfile"), aname="_customComplyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"disabledExpressionList"), aname="_disabledExpressionList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileConfigInfo_Def not in ns0.HostProfileConfigInfo_Def.__bases__: + bases = list(ns0.HostProfileConfigInfo_Def.__bases__) + bases.insert(0, ns0.ProfileConfigInfo_Def) + ns0.HostProfileConfigInfo_Def.__bases__ = tuple(bases) + + ns0.ProfileConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProfileConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProfileConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProfileConfigSpec_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ProfileCreateSpec_Def not in ns0.HostProfileConfigSpec_Def.__bases__: + bases = list(ns0.HostProfileConfigSpec_Def.__bases__) + bases.insert(0, ns0.ProfileCreateSpec_Def) + ns0.HostProfileConfigSpec_Def.__bases__ = tuple(bases) + + ns0.ProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProfileCompleteConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProfileCompleteConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProfileCompleteConfigSpec_Def.schema + TClist = [GTD("urn:vim25","HostApplyProfile",lazy=True)(pname=(ns,"applyProfile"), aname="_applyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"customComplyProfile"), aname="_customComplyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"disabledExpressionListChanged"), aname="_disabledExpressionListChanged", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"disabledExpressionList"), aname="_disabledExpressionList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostProfileConfigSpec_Def not in ns0.HostProfileCompleteConfigSpec_Def.__bases__: + bases = list(ns0.HostProfileCompleteConfigSpec_Def.__bases__) + bases.insert(0, ns0.HostProfileConfigSpec_Def) + ns0.HostProfileCompleteConfigSpec_Def.__bases__ = tuple(bases) + + ns0.HostProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProfileHostBasedConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProfileHostBasedConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProfileHostBasedConfigSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HostProfileConfigSpec_Def not in ns0.HostProfileHostBasedConfigSpec_Def.__bases__: + bases = list(ns0.HostProfileHostBasedConfigSpec_Def.__bases__) + bases.insert(0, ns0.HostProfileConfigSpec_Def) + ns0.HostProfileHostBasedConfigSpec_Def.__bases__ = tuple(bases) + + ns0.HostProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProfileUpdateReferenceHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostProfileUpdateReferenceHostRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HostProfileUpdateReferenceHostRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + return + Holder.__name__ = "HostProfileUpdateReferenceHostRequestType_Holder" + self.pyclass = Holder + + class HostProfileUpdateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostProfileUpdateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HostProfileUpdateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProfileConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._config = None + return + Holder.__name__ = "HostProfileUpdateRequestType_Holder" + self.pyclass = Holder + + class HostProfileExecuteRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostProfileExecuteRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HostProfileExecuteRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileDeferredPolicyOptionParameter",lazy=True)(pname=(ns,"deferredParam"), aname="_deferredParam", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._deferredParam = [] + return + Holder.__name__ = "HostProfileExecuteRequestType_Holder" + self.pyclass = Holder + + class HostProfileManagerConfigTaskList_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostProfileManagerConfigTaskList") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostProfileManagerConfigTaskList_Def.schema + TClist = [GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"taskDescription"), aname="_taskDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostProfileManagerConfigTaskList_Def.__bases__: + bases = list(ns0.HostProfileManagerConfigTaskList_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostProfileManagerConfigTaskList_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostProfileApplyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostProfileApplyRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HostProfileApplyRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._configSpec = None + return + Holder.__name__ = "HostProfileApplyRequestType_Holder" + self.pyclass = Holder + + class HostProfileGenerateConfigTaskListRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostProfileGenerateConfigTaskListRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HostProfileGenerateConfigTaskListRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._configSpec = None + self._host = None + return + Holder.__name__ = "HostProfileGenerateConfigTaskListRequestType_Holder" + self.pyclass = Holder + + class HostProfileQueryProfileMetadataRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostProfileQueryProfileMetadataRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HostProfileQueryProfileMetadataRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"profileName"), aname="_profileName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._profileName = [] + return + Holder.__name__ = "HostProfileQueryProfileMetadataRequestType_Holder" + self.pyclass = Holder + + class HostProfileCreateDefaultProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "HostProfileCreateDefaultProfileRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.HostProfileCreateDefaultProfileRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"profileType"), aname="_profileType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._profileType = None + return + Holder.__name__ = "HostProfileCreateDefaultProfileRequestType_Holder" + self.pyclass = Holder + + class RemoveScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveScheduledTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveScheduledTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RemoveScheduledTaskRequestType_Holder" + self.pyclass = Holder + + class ReconfigureScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ReconfigureScheduledTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ReconfigureScheduledTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._spec = None + return + Holder.__name__ = "ReconfigureScheduledTaskRequestType_Holder" + self.pyclass = Holder + + class RunScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RunScheduledTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RunScheduledTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "RunScheduledTaskRequestType_Holder" + self.pyclass = Holder + + class ScheduledTaskDetail_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskDetail") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskDetail_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"frequency"), aname="_frequency", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TypeDescription_Def not in ns0.ScheduledTaskDetail_Def.__bases__: + bases = list(ns0.ScheduledTaskDetail_Def.__bases__) + bases.insert(0, ns0.TypeDescription_Def) + ns0.ScheduledTaskDetail_Def.__bases__ = tuple(bases) + + ns0.TypeDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfScheduledTaskDetail_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfScheduledTaskDetail") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfScheduledTaskDetail_Def.schema + TClist = [GTD("urn:vim25","ScheduledTaskDetail",lazy=True)(pname=(ns,"ScheduledTaskDetail"), aname="_ScheduledTaskDetail", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ScheduledTaskDetail = [] + return + Holder.__name__ = "ArrayOfScheduledTaskDetail_Holder" + self.pyclass = Holder + + class ScheduledTaskDescription_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskDescription") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskDescription_Def.schema + TClist = [GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskDetail",lazy=True)(pname=(ns,"schedulerInfo"), aname="_schedulerInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"dayOfWeek"), aname="_dayOfWeek", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"weekOfMonth"), aname="_weekOfMonth", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ScheduledTaskDescription_Def.__bases__: + bases = list(ns0.ScheduledTaskDescription_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ScheduledTaskDescription_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModifiedTime"), aname="_lastModifiedTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lastModifiedUser"), aname="_lastModifiedUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"nextRunTime"), aname="_nextRunTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"prevRunTime"), aname="_prevRunTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"result"), aname="_result", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"progress"), aname="_progress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"activeTask"), aname="_activeTask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"taskObject"), aname="_taskObject", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ScheduledTaskSpec_Def not in ns0.ScheduledTaskInfo_Def.__bases__: + bases = list(ns0.ScheduledTaskInfo_Def.__bases__) + bases.insert(0, ns0.ScheduledTaskSpec_Def) + ns0.ScheduledTaskInfo_Def.__bases__ = tuple(bases) + + ns0.ScheduledTaskSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CreateScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateScheduledTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateScheduledTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + self._spec = None + return + Holder.__name__ = "CreateScheduledTaskRequestType_Holder" + self.pyclass = Holder + + class RetrieveEntityScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveEntityScheduledTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveEntityScheduledTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = None + return + Holder.__name__ = "RetrieveEntityScheduledTaskRequestType_Holder" + self.pyclass = Holder + + class CreateObjectScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateObjectScheduledTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateObjectScheduledTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._obj = None + self._spec = None + return + Holder.__name__ = "CreateObjectScheduledTaskRequestType_Holder" + self.pyclass = Holder + + class RetrieveObjectScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RetrieveObjectScheduledTaskRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RetrieveObjectScheduledTaskRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._obj = None + return + Holder.__name__ = "RetrieveObjectScheduledTaskRequestType_Holder" + self.pyclass = Holder + + class TaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "TaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.TaskScheduler_Def.schema + TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"activeTime"), aname="_activeTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"expireTime"), aname="_expireTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.TaskScheduler_Def.__bases__: + bases = list(ns0.TaskScheduler_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.TaskScheduler_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class AfterStartupTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "AfterStartupTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.AfterStartupTaskScheduler_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"minute"), aname="_minute", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskScheduler_Def not in ns0.AfterStartupTaskScheduler_Def.__bases__: + bases = list(ns0.AfterStartupTaskScheduler_Def.__bases__) + bases.insert(0, ns0.TaskScheduler_Def) + ns0.AfterStartupTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.TaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class OnceTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "OnceTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.OnceTaskScheduler_Def.schema + TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"runAt"), aname="_runAt", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskScheduler_Def not in ns0.OnceTaskScheduler_Def.__bases__: + bases = list(ns0.OnceTaskScheduler_Def.__bases__) + bases.insert(0, ns0.TaskScheduler_Def) + ns0.OnceTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.TaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class RecurrentTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "RecurrentTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.RecurrentTaskScheduler_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.TaskScheduler_Def not in ns0.RecurrentTaskScheduler_Def.__bases__: + bases = list(ns0.RecurrentTaskScheduler_Def.__bases__) + bases.insert(0, ns0.TaskScheduler_Def) + ns0.RecurrentTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.TaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HourlyTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HourlyTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HourlyTaskScheduler_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"minute"), aname="_minute", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.RecurrentTaskScheduler_Def not in ns0.HourlyTaskScheduler_Def.__bases__: + bases = list(ns0.HourlyTaskScheduler_Def.__bases__) + bases.insert(0, ns0.RecurrentTaskScheduler_Def) + ns0.HourlyTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.RecurrentTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DailyTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DailyTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DailyTaskScheduler_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"hour"), aname="_hour", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.HourlyTaskScheduler_Def not in ns0.DailyTaskScheduler_Def.__bases__: + bases = list(ns0.DailyTaskScheduler_Def.__bases__) + bases.insert(0, ns0.HourlyTaskScheduler_Def) + ns0.DailyTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.HourlyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class WeeklyTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "WeeklyTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.WeeklyTaskScheduler_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"sunday"), aname="_sunday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"monday"), aname="_monday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tuesday"), aname="_tuesday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"wednesday"), aname="_wednesday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thursday"), aname="_thursday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"friday"), aname="_friday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"saturday"), aname="_saturday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DailyTaskScheduler_Def not in ns0.WeeklyTaskScheduler_Def.__bases__: + bases = list(ns0.WeeklyTaskScheduler_Def.__bases__) + bases.insert(0, ns0.DailyTaskScheduler_Def) + ns0.WeeklyTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.DailyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MonthlyTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MonthlyTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MonthlyTaskScheduler_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DailyTaskScheduler_Def not in ns0.MonthlyTaskScheduler_Def.__bases__: + bases = list(ns0.MonthlyTaskScheduler_Def.__bases__) + bases.insert(0, ns0.DailyTaskScheduler_Def) + ns0.MonthlyTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.DailyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class MonthlyByDayTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MonthlyByDayTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MonthlyByDayTaskScheduler_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"day"), aname="_day", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MonthlyTaskScheduler_Def not in ns0.MonthlyByDayTaskScheduler_Def.__bases__: + bases = list(ns0.MonthlyByDayTaskScheduler_Def.__bases__) + bases.insert(0, ns0.MonthlyTaskScheduler_Def) + ns0.MonthlyByDayTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.MonthlyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class DayOfWeek_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DayOfWeek") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class WeekOfMonth_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "WeekOfMonth") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class MonthlyByWeekdayTaskScheduler_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "MonthlyByWeekdayTaskScheduler") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.MonthlyByWeekdayTaskScheduler_Def.schema + TClist = [GTD("urn:vim25","WeekOfMonth",lazy=True)(pname=(ns,"offset"), aname="_offset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DayOfWeek",lazy=True)(pname=(ns,"weekday"), aname="_weekday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.MonthlyTaskScheduler_Def not in ns0.MonthlyByWeekdayTaskScheduler_Def.__bases__: + bases = list(ns0.MonthlyByWeekdayTaskScheduler_Def.__bases__) + bases.insert(0, ns0.MonthlyTaskScheduler_Def) + ns0.MonthlyByWeekdayTaskScheduler_Def.__bases__ = tuple(bases) + + ns0.MonthlyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ScheduledTaskSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ScheduledTaskSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ScheduledTaskSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskScheduler",lazy=True)(pname=(ns,"scheduler"), aname="_scheduler", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Action",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"notification"), aname="_notification", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ScheduledTaskSpec_Def.__bases__: + bases = list(ns0.ScheduledTaskSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ScheduledTaskSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppCloneSpecNetworkMappingPair_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppCloneSpecNetworkMappingPair") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppCloneSpecNetworkMappingPair_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destination"), aname="_destination", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VAppCloneSpecNetworkMappingPair_Def.__bases__: + bases = list(ns0.VAppCloneSpecNetworkMappingPair_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VAppCloneSpecNetworkMappingPair_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppCloneSpecNetworkMappingPair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppCloneSpecNetworkMappingPair") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppCloneSpecNetworkMappingPair_Def.schema + TClist = [GTD("urn:vim25","VAppCloneSpecNetworkMappingPair",lazy=True)(pname=(ns,"VAppCloneSpecNetworkMappingPair"), aname="_VAppCloneSpecNetworkMappingPair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppCloneSpecNetworkMappingPair = [] + return + Holder.__name__ = "ArrayOfVAppCloneSpecNetworkMappingPair_Holder" + self.pyclass = Holder + + class VAppCloneSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppCloneSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppCloneSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"location"), aname="_location", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"resourceSpec"), aname="_resourceSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmFolder"), aname="_vmFolder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppCloneSpecNetworkMappingPair",lazy=True)(pname=(ns,"networkMapping"), aname="_networkMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VAppCloneSpec_Def.__bases__: + bases = list(ns0.VAppCloneSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VAppCloneSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppAutoStartAction_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VAppAutoStartAction") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VAppEntityConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppEntityConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppEntityConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"tag"), aname="_tag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startOrder"), aname="_startOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startDelay"), aname="_startDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"waitingForGuest"), aname="_waitingForGuest", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"startAction"), aname="_startAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"stopDelay"), aname="_stopDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"stopAction"), aname="_stopAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VAppEntityConfigInfo_Def.__bases__: + bases = list(ns0.VAppEntityConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VAppEntityConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppEntityConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppEntityConfigInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppEntityConfigInfo_Def.schema + TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"VAppEntityConfigInfo"), aname="_VAppEntityConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppEntityConfigInfo = [] + return + Holder.__name__ = "ArrayOfVAppEntityConfigInfo_Holder" + self.pyclass = Holder + + class VAppIPAssignmentInfoIpAllocationPolicy_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VAppIPAssignmentInfoIpAllocationPolicy") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VAppIPAssignmentInfoAllocationSchemes_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VAppIPAssignmentInfoAllocationSchemes") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VAppIPAssignmentInfoProtocols_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VAppIPAssignmentInfoProtocols") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VAppIPAssignmentInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppIPAssignmentInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppIPAssignmentInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"supportedAllocationScheme"), aname="_supportedAllocationScheme", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAllocationPolicy"), aname="_ipAllocationPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedIpProtocol"), aname="_supportedIpProtocol", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipProtocol"), aname="_ipProtocol", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VAppIPAssignmentInfo_Def.__bases__: + bases = list(ns0.VAppIPAssignmentInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VAppIPAssignmentInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IpPoolIpPoolConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IpPoolIpPoolConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IpPoolIpPoolConfigInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"subnetAddress"), aname="_subnetAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"netmask"), aname="_netmask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"range"), aname="_range", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dns"), aname="_dns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpServerAvailable"), aname="_dhcpServerAvailable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipPoolEnabled"), aname="_ipPoolEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.IpPoolIpPoolConfigInfo_Def.__bases__: + bases = list(ns0.IpPoolIpPoolConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.IpPoolIpPoolConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class IpPoolAssociation_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IpPoolAssociation") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IpPoolAssociation_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"networkName"), aname="_networkName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.IpPoolAssociation_Def.__bases__: + bases = list(ns0.IpPoolAssociation_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.IpPoolAssociation_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfIpPoolAssociation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfIpPoolAssociation") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfIpPoolAssociation_Def.schema + TClist = [GTD("urn:vim25","IpPoolAssociation",lazy=True)(pname=(ns,"IpPoolAssociation"), aname="_IpPoolAssociation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._IpPoolAssociation = [] + return + Holder.__name__ = "ArrayOfIpPoolAssociation_Holder" + self.pyclass = Holder + + class IpPool_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "IpPool") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.IpPool_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPoolIpPoolConfigInfo",lazy=True)(pname=(ns,"ipv4Config"), aname="_ipv4Config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPoolIpPoolConfigInfo",lazy=True)(pname=(ns,"ipv6Config"), aname="_ipv6Config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsDomain"), aname="_dnsDomain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsSearchPath"), aname="_dnsSearchPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostPrefix"), aname="_hostPrefix", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"httpProxy"), aname="_httpProxy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPoolAssociation",lazy=True)(pname=(ns,"networkAssociation"), aname="_networkAssociation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.IpPool_Def.__bases__: + bases = list(ns0.IpPool_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.IpPool_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfIpPool_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfIpPool") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfIpPool_Def.schema + TClist = [GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"IpPool"), aname="_IpPool", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._IpPool = [] + return + Holder.__name__ = "ArrayOfIpPool_Holder" + self.pyclass = Holder + + class VAppOvfSectionInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppOvfSectionInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppOvfSectionInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"namespace"), aname="_namespace", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"atEnvelopeLevel"), aname="_atEnvelopeLevel", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contents"), aname="_contents", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VAppOvfSectionInfo_Def.__bases__: + bases = list(ns0.VAppOvfSectionInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VAppOvfSectionInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppOvfSectionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppOvfSectionInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppOvfSectionInfo_Def.schema + TClist = [GTD("urn:vim25","VAppOvfSectionInfo",lazy=True)(pname=(ns,"VAppOvfSectionInfo"), aname="_VAppOvfSectionInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppOvfSectionInfo = [] + return + Holder.__name__ = "ArrayOfVAppOvfSectionInfo_Holder" + self.pyclass = Holder + + class VAppProductInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppProductInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppProductInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"classId"), aname="_classId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullVersion"), aname="_fullVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendorUrl"), aname="_vendorUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productUrl"), aname="_productUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"appUrl"), aname="_appUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VAppProductInfo_Def.__bases__: + bases = list(ns0.VAppProductInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VAppProductInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppProductInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppProductInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppProductInfo_Def.schema + TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"VAppProductInfo"), aname="_VAppProductInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppProductInfo = [] + return + Holder.__name__ = "ArrayOfVAppProductInfo_Holder" + self.pyclass = Holder + + class VAppPropertyInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppPropertyInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppPropertyInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"classId"), aname="_classId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"userConfigurable"), aname="_userConfigurable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VAppPropertyInfo_Def.__bases__: + bases = list(ns0.VAppPropertyInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VAppPropertyInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppPropertyInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppPropertyInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppPropertyInfo_Def.schema + TClist = [GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"VAppPropertyInfo"), aname="_VAppPropertyInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppPropertyInfo = [] + return + Holder.__name__ = "ArrayOfVAppPropertyInfo_Holder" + self.pyclass = Holder + + class VAppConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppConfigInfo_Def.schema + TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"entityConfig"), aname="_entityConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigInfo_Def not in ns0.VAppConfigInfo_Def.__bases__: + bases = list(ns0.VAppConfigInfo_Def.__bases__) + bases.insert(0, ns0.VmConfigInfo_Def) + ns0.VAppConfigInfo_Def.__bases__ = tuple(bases) + + ns0.VmConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppConfigSpec_Def.schema + TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"entityConfig"), aname="_entityConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VmConfigSpec_Def not in ns0.VAppConfigSpec_Def.__bases__: + bases = list(ns0.VAppConfigSpec_Def.__bases__) + bases.insert(0, ns0.VmConfigSpec_Def) + ns0.VAppConfigSpec_Def.__bases__ = tuple(bases) + + ns0.VmConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualAppImportSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualAppImportSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualAppImportSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppConfigSpec",lazy=True)(pname=(ns,"vAppConfigSpec"), aname="_vAppConfigSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"resourcePoolSpec"), aname="_resourcePoolSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"child"), aname="_child", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ImportSpec_Def not in ns0.VirtualAppImportSpec_Def.__bases__: + bases = list(ns0.VirtualAppImportSpec_Def.__bases__) + bases.insert(0, ns0.ImportSpec_Def) + ns0.VirtualAppImportSpec_Def.__bases__ = tuple(bases) + + ns0.ImportSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigInfo_Def.schema + TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppIPAssignmentInfo",lazy=True)(pname=(ns,"ipAssignment"), aname="_ipAssignment", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eula"), aname="_eula", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppOvfSectionInfo",lazy=True)(pname=(ns,"ovfSection"), aname="_ovfSection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfEnvironmentTransport"), aname="_ovfEnvironmentTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"installBootStopDelay"), aname="_installBootStopDelay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmConfigInfo_Def.__bases__: + bases = list(ns0.VmConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VmConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VmConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VmConfigSpec_Def.schema + TClist = [GTD("urn:vim25","VAppProductSpec",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppPropertySpec",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppIPAssignmentInfo",lazy=True)(pname=(ns,"ipAssignment"), aname="_ipAssignment", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eula"), aname="_eula", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppOvfSectionSpec",lazy=True)(pname=(ns,"ovfSection"), aname="_ovfSection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfEnvironmentTransport"), aname="_ovfEnvironmentTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"installBootStopDelay"), aname="_installBootStopDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VmConfigSpec_Def.__bases__: + bases = list(ns0.VmConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VmConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VAppProductSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppProductSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppProductSpec_Def.schema + TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.VAppProductSpec_Def.__bases__: + bases = list(ns0.VAppProductSpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.VAppProductSpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppProductSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppProductSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppProductSpec_Def.schema + TClist = [GTD("urn:vim25","VAppProductSpec",lazy=True)(pname=(ns,"VAppProductSpec"), aname="_VAppProductSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppProductSpec = [] + return + Holder.__name__ = "ArrayOfVAppProductSpec_Holder" + self.pyclass = Holder + + class VAppPropertySpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppPropertySpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppPropertySpec_Def.schema + TClist = [GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.VAppPropertySpec_Def.__bases__: + bases = list(ns0.VAppPropertySpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.VAppPropertySpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppPropertySpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppPropertySpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppPropertySpec_Def.schema + TClist = [GTD("urn:vim25","VAppPropertySpec",lazy=True)(pname=(ns,"VAppPropertySpec"), aname="_VAppPropertySpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppPropertySpec = [] + return + Holder.__name__ = "ArrayOfVAppPropertySpec_Holder" + self.pyclass = Holder + + class VAppOvfSectionSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VAppOvfSectionSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VAppOvfSectionSpec_Def.schema + TClist = [GTD("urn:vim25","VAppOvfSectionInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.VAppOvfSectionSpec_Def.__bases__: + bases = list(ns0.VAppOvfSectionSpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.VAppOvfSectionSpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVAppOvfSectionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVAppOvfSectionSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVAppOvfSectionSpec_Def.schema + TClist = [GTD("urn:vim25","VAppOvfSectionSpec",lazy=True)(pname=(ns,"VAppOvfSectionSpec"), aname="_VAppOvfSectionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VAppOvfSectionSpec = [] + return + Holder.__name__ = "ArrayOfVAppOvfSectionSpec_Holder" + self.pyclass = Holder + + class OpenInventoryViewFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "OpenInventoryViewFolderRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.OpenInventoryViewFolderRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = [] + return + Holder.__name__ = "OpenInventoryViewFolderRequestType_Holder" + self.pyclass = Holder + + class CloseInventoryViewFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CloseInventoryViewFolderRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CloseInventoryViewFolderRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._entity = [] + return + Holder.__name__ = "CloseInventoryViewFolderRequestType_Holder" + self.pyclass = Holder + + class ModifyListViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ModifyListViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ModifyListViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"add"), aname="_add", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"remove"), aname="_remove", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._add = [] + self._remove = [] + return + Holder.__name__ = "ModifyListViewRequestType_Holder" + self.pyclass = Holder + + class ResetListViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetListViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetListViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._obj = [] + return + Holder.__name__ = "ResetListViewRequestType_Holder" + self.pyclass = Holder + + class ResetListViewFromViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ResetListViewFromViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ResetListViewFromViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"view"), aname="_view", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._view = None + return + Holder.__name__ = "ResetListViewFromViewRequestType_Holder" + self.pyclass = Holder + + class DestroyViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "DestroyViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.DestroyViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "DestroyViewRequestType_Holder" + self.pyclass = Holder + + class CreateInventoryViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateInventoryViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateInventoryViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + return + Holder.__name__ = "CreateInventoryViewRequestType_Holder" + self.pyclass = Holder + + class CreateContainerViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateContainerViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateContainerViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"container"), aname="_container", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recursive"), aname="_recursive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._container = None + self._type = [] + self._recursive = None + return + Holder.__name__ = "CreateContainerViewRequestType_Holder" + self.pyclass = Holder + + class CreateListViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateListViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateListViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._obj = [] + return + Holder.__name__ = "CreateListViewRequestType_Holder" + self.pyclass = Holder + + class CreateListViewFromViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CreateListViewFromViewRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CreateListViewFromViewRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"view"), aname="_view", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._view = None + return + Holder.__name__ = "CreateListViewFromViewRequestType_Holder" + self.pyclass = Holder + + class VirtualMachineAffinityInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineAffinityInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineAffinityInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"affinitySet"), aname="_affinitySet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineAffinityInfo_Def.__bases__: + bases = list(ns0.VirtualMachineAffinityInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineAffinityInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineBootOptions_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineBootOptions") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineBootOptions_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"bootDelay"), aname="_bootDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enterBIOSSetup"), aname="_enterBIOSSetup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineBootOptions_Def.__bases__: + bases = list(ns0.VirtualMachineBootOptions_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineBootOptions_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineCapability_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineCapability") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineCapability_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"snapshotOperationsSupported"), aname="_snapshotOperationsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multipleSnapshotsSupported"), aname="_multipleSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"snapshotConfigSupported"), aname="_snapshotConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"poweredOffSnapshotsSupported"), aname="_poweredOffSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memorySnapshotsSupported"), aname="_memorySnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"revertToSnapshotSupported"), aname="_revertToSnapshotSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"quiescedSnapshotsSupported"), aname="_quiescedSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"disableSnapshotsSupported"), aname="_disableSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"lockSnapshotsSupported"), aname="_lockSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"consolePreferencesSupported"), aname="_consolePreferencesSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuFeatureMaskSupported"), aname="_cpuFeatureMaskSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"s1AcpiManagementSupported"), aname="_s1AcpiManagementSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"settingScreenResolutionSupported"), aname="_settingScreenResolutionSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"toolsAutoUpdateSupported"), aname="_toolsAutoUpdateSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmNpivWwnSupported"), aname="_vmNpivWwnSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivWwnOnNonRdmVmSupported"), aname="_npivWwnOnNonRdmVmSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmNpivWwnDisableSupported"), aname="_vmNpivWwnDisableSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmNpivWwnUpdateSupported"), aname="_vmNpivWwnUpdateSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"swapPlacementSupported"), aname="_swapPlacementSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"toolsSyncTimeSupported"), aname="_toolsSyncTimeSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"virtualMmuUsageSupported"), aname="_virtualMmuUsageSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"diskSharesSupported"), aname="_diskSharesSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"bootOptionsSupported"), aname="_bootOptionsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"settingVideoRamSizeSupported"), aname="_settingVideoRamSizeSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"settingDisplayTopologySupported"), aname="_settingDisplayTopologySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recordReplaySupported"), aname="_recordReplaySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"changeTrackingSupported"), aname="_changeTrackingSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineCapability_Def.__bases__: + bases = list(ns0.VirtualMachineCapability_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineCapability_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineCdromInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineCdromInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineCdromInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineCdromInfo_Def.__bases__: + bases = list(ns0.VirtualMachineCdromInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineCdromInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineCdromInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineCdromInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineCdromInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineCdromInfo",lazy=True)(pname=(ns,"VirtualMachineCdromInfo"), aname="_VirtualMachineCdromInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineCdromInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineCdromInfo_Holder" + self.pyclass = Holder + + class VirtualMachineCloneSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineCloneSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineCloneSpec_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineRelocateSpec",lazy=True)(pname=(ns,"location"), aname="_location", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"customization"), aname="_customization", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"powerOn"), aname="_powerOn", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineCloneSpec_Def.__bases__: + bases = list(ns0.VirtualMachineCloneSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineCloneSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineConfigInfoNpivWwnType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigInfoNpivWwnType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineConfigInfoSwapPlacementType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigInfoSwapPlacementType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineConfigInfoDatastoreUrlPair_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigInfoDatastoreUrlPair") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.__bases__: + bases = list(ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineConfigInfoDatastoreUrlPair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineConfigInfoDatastoreUrlPair") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineConfigInfoDatastoreUrlPair_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineConfigInfoDatastoreUrlPair",lazy=True)(pname=(ns,"VirtualMachineConfigInfoDatastoreUrlPair"), aname="_VirtualMachineConfigInfoDatastoreUrlPair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineConfigInfoDatastoreUrlPair = [] + return + Holder.__name__ = "ArrayOfVirtualMachineConfigInfoDatastoreUrlPair_Holder" + self.pyclass = Holder + + class VirtualMachineConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineConfigInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"modified"), aname="_modified", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivNodeWorldWideName"), aname="_npivNodeWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivPortWorldWideName"), aname="_npivPortWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"npivWorldWideNameType"), aname="_npivWorldWideNameType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredNodeWwns"), aname="_npivDesiredNodeWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredPortWwns"), aname="_npivDesiredPortWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivTemporaryDisabled"), aname="_npivTemporaryDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivOnNonRdmDisks"), aname="_npivOnNonRdmDisks", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locationId"), aname="_locationId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"alternateGuestName"), aname="_alternateGuestName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileInfo",lazy=True)(pname=(ns,"files"), aname="_files", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ToolsConfigInfo",lazy=True)(pname=(ns,"tools"), aname="_tools", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFlagInfo",lazy=True)(pname=(ns,"flags"), aname="_flags", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConsolePreferences",lazy=True)(pname=(ns,"consolePreferences"), aname="_consolePreferences", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDefaultPowerOpInfo",lazy=True)(pname=(ns,"defaultPowerOps"), aname="_defaultPowerOps", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualHardware",lazy=True)(pname=(ns,"hardware"), aname="_hardware", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"cpuAllocation"), aname="_cpuAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"memoryAllocation"), aname="_memoryAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memoryHotAddEnabled"), aname="_memoryHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotAddEnabled"), aname="_cpuHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotRemoveEnabled"), aname="_cpuHotRemoveEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hotPlugMemoryLimit"), aname="_hotPlugMemoryLimit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hotPlugMemoryIncrementSize"), aname="_hotPlugMemoryIncrementSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"cpuAffinity"), aname="_cpuAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"memoryAffinity"), aname="_memoryAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineNetworkShaperInfo",lazy=True)(pname=(ns,"networkShaper"), aname="_networkShaper", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"extraConfig"), aname="_extraConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeatureMask"), aname="_cpuFeatureMask", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigInfoDatastoreUrlPair",lazy=True)(pname=(ns,"datastoreUrl"), aname="_datastoreUrl", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"swapPlacement"), aname="_swapPlacement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineBootOptions",lazy=True)(pname=(ns,"bootOptions"), aname="_bootOptions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FaultToleranceConfigInfo",lazy=True)(pname=(ns,"ftInfo"), aname="_ftInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmConfigInfo",lazy=True)(pname=(ns,"vAppConfig"), aname="_vAppConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vAssertsEnabled"), aname="_vAssertsEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"changeTrackingEnabled"), aname="_changeTrackingEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineConfigInfo_Def.__bases__: + bases = list(ns0.VirtualMachineConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineConfigOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineConfigOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestOsDescriptor",lazy=True)(pname=(ns,"guestOSDescriptor"), aname="_guestOSDescriptor", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"guestOSDefaultIndex"), aname="_guestOSDefaultIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualHardwareOption",lazy=True)(pname=(ns,"hardwareOptions"), aname="_hardwareOptions", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCapability",lazy=True)(pname=(ns,"capabilities"), aname="_capabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreOption",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"defaultDevice"), aname="_defaultDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedMonitorType"), aname="_supportedMonitorType", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedOvfEnvironmentTransport"), aname="_supportedOvfEnvironmentTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedOvfInstallTransport"), aname="_supportedOvfInstallTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineConfigOption_Def.__bases__: + bases = list(ns0.VirtualMachineConfigOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineConfigOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineConfigOptionDescriptor_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigOptionDescriptor") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineConfigOptionDescriptor_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"createSupported"), aname="_createSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"defaultConfigOption"), aname="_defaultConfigOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineConfigOptionDescriptor_Def.__bases__: + bases = list(ns0.VirtualMachineConfigOptionDescriptor_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineConfigOptionDescriptor_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineConfigOptionDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineConfigOptionDescriptor") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineConfigOptionDescriptor_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineConfigOptionDescriptor",lazy=True)(pname=(ns,"VirtualMachineConfigOptionDescriptor"), aname="_VirtualMachineConfigOptionDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineConfigOptionDescriptor = [] + return + Holder.__name__ = "ArrayOfVirtualMachineConfigOptionDescriptor_Holder" + self.pyclass = Holder + + class VirtualMachineConfigSpecNpivWwnOp_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigSpecNpivWwnOp") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineCpuIdInfoSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineCpuIdInfoSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineCpuIdInfoSpec_Def.schema + TClist = [GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ArrayUpdateSpec_Def not in ns0.VirtualMachineCpuIdInfoSpec_Def.__bases__: + bases = list(ns0.VirtualMachineCpuIdInfoSpec_Def.__bases__) + bases.insert(0, ns0.ArrayUpdateSpec_Def) + ns0.VirtualMachineCpuIdInfoSpec_Def.__bases__ = tuple(bases) + + ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineCpuIdInfoSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineCpuIdInfoSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineCpuIdInfoSpec_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineCpuIdInfoSpec",lazy=True)(pname=(ns,"VirtualMachineCpuIdInfoSpec"), aname="_VirtualMachineCpuIdInfoSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineCpuIdInfoSpec = [] + return + Holder.__name__ = "ArrayOfVirtualMachineCpuIdInfoSpec_Holder" + self.pyclass = Holder + + class VirtualMachineConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineConfigSpec_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivNodeWorldWideName"), aname="_npivNodeWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivPortWorldWideName"), aname="_npivPortWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"npivWorldWideNameType"), aname="_npivWorldWideNameType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredNodeWwns"), aname="_npivDesiredNodeWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredPortWwns"), aname="_npivDesiredPortWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivTemporaryDisabled"), aname="_npivTemporaryDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivOnNonRdmDisks"), aname="_npivOnNonRdmDisks", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"npivWorldWideNameOp"), aname="_npivWorldWideNameOp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locationId"), aname="_locationId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"alternateGuestName"), aname="_alternateGuestName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileInfo",lazy=True)(pname=(ns,"files"), aname="_files", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ToolsConfigInfo",lazy=True)(pname=(ns,"tools"), aname="_tools", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFlagInfo",lazy=True)(pname=(ns,"flags"), aname="_flags", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConsolePreferences",lazy=True)(pname=(ns,"consolePreferences"), aname="_consolePreferences", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDefaultPowerOpInfo",lazy=True)(pname=(ns,"powerOpInfo"), aname="_powerOpInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCPUs"), aname="_numCPUs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memoryHotAddEnabled"), aname="_memoryHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotAddEnabled"), aname="_cpuHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotRemoveEnabled"), aname="_cpuHotRemoveEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConfigSpec",lazy=True)(pname=(ns,"deviceChange"), aname="_deviceChange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"cpuAllocation"), aname="_cpuAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"memoryAllocation"), aname="_memoryAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"cpuAffinity"), aname="_cpuAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"memoryAffinity"), aname="_memoryAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineNetworkShaperInfo",lazy=True)(pname=(ns,"networkShaper"), aname="_networkShaper", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCpuIdInfoSpec",lazy=True)(pname=(ns,"cpuFeatureMask"), aname="_cpuFeatureMask", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"extraConfig"), aname="_extraConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"swapPlacement"), aname="_swapPlacement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineBootOptions",lazy=True)(pname=(ns,"bootOptions"), aname="_bootOptions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmConfigSpec",lazy=True)(pname=(ns,"vAppConfig"), aname="_vAppConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FaultToleranceConfigInfo",lazy=True)(pname=(ns,"ftInfo"), aname="_ftInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vAppConfigRemoved"), aname="_vAppConfigRemoved", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vAssertsEnabled"), aname="_vAssertsEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"changeTrackingEnabled"), aname="_changeTrackingEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineConfigSpec_Def.__bases__: + bases = list(ns0.VirtualMachineConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ConfigTarget_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ConfigTarget") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ConfigTarget_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numCpus"), aname="_numCpus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNumaNodes"), aname="_numNumaNodes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDatastoreInfo",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualPortgroupInfo",lazy=True)(pname=(ns,"distributedVirtualPortgroup"), aname="_distributedVirtualPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchInfo",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCdromInfo",lazy=True)(pname=(ns,"cdRom"), aname="_cdRom", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSerialInfo",lazy=True)(pname=(ns,"serial"), aname="_serial", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineParallelInfo",lazy=True)(pname=(ns,"parallel"), aname="_parallel", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSoundInfo",lazy=True)(pname=(ns,"sound"), aname="_sound", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineUsbInfo",lazy=True)(pname=(ns,"usb"), aname="_usb", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFloppyInfo",lazy=True)(pname=(ns,"floppy"), aname="_floppy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineLegacyNetworkSwitchInfo",lazy=True)(pname=(ns,"legacyNetworkInfo"), aname="_legacyNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineScsiPassthroughInfo",lazy=True)(pname=(ns,"scsiPassthrough"), aname="_scsiPassthrough", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineScsiDiskDeviceInfo",lazy=True)(pname=(ns,"scsiDisk"), aname="_scsiDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineIdeDiskDeviceInfo",lazy=True)(pname=(ns,"ideDisk"), aname="_ideDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemMBOptimalPerf"), aname="_maxMemMBOptimalPerf", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolRuntimeInfo",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoVmotion"), aname="_autoVmotion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePciPassthroughInfo",lazy=True)(pname=(ns,"pciPassthrough"), aname="_pciPassthrough", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ConfigTarget_Def.__bases__: + bases = list(ns0.ConfigTarget_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ConfigTarget_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineConsolePreferences_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineConsolePreferences") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineConsolePreferences_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"powerOnWhenOpened"), aname="_powerOnWhenOpened", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enterFullScreenOnPowerOn"), aname="_enterFullScreenOnPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"closeOnPowerOffOrSuspend"), aname="_closeOnPowerOffOrSuspend", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineConsolePreferences_Def.__bases__: + bases = list(ns0.VirtualMachineConsolePreferences_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineConsolePreferences_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineDatastoreInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineDatastoreInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineDatastoreInfo_Def.schema + TClist = [GTD("urn:vim25","DatastoreSummary",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxFileSize"), aname="_maxFileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mode"), aname="_mode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineDatastoreInfo_Def.__bases__: + bases = list(ns0.VirtualMachineDatastoreInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineDatastoreInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineDatastoreInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineDatastoreInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineDatastoreInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineDatastoreInfo",lazy=True)(pname=(ns,"VirtualMachineDatastoreInfo"), aname="_VirtualMachineDatastoreInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineDatastoreInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineDatastoreInfo_Holder" + self.pyclass = Holder + + class VirtualMachineDatastoreVolumeOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineDatastoreVolumeOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineDatastoreVolumeOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"fileSystemType"), aname="_fileSystemType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"majorVersion"), aname="_majorVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineDatastoreVolumeOption_Def.__bases__: + bases = list(ns0.VirtualMachineDatastoreVolumeOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineDatastoreVolumeOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineDatastoreVolumeOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineDatastoreVolumeOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineDatastoreVolumeOption_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineDatastoreVolumeOption",lazy=True)(pname=(ns,"VirtualMachineDatastoreVolumeOption"), aname="_VirtualMachineDatastoreVolumeOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineDatastoreVolumeOption = [] + return + Holder.__name__ = "ArrayOfVirtualMachineDatastoreVolumeOption_Holder" + self.pyclass = Holder + + class DatastoreOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "DatastoreOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.DatastoreOption_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineDatastoreVolumeOption",lazy=True)(pname=(ns,"unsupportedVolumes"), aname="_unsupportedVolumes", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.DatastoreOption_Def.__bases__: + bases = list(ns0.DatastoreOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.DatastoreOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachinePowerOpType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachinePowerOpType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineStandbyActionType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineStandbyActionType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineDefaultPowerOpInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineDefaultPowerOpInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineDefaultPowerOpInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"powerOffType"), aname="_powerOffType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"suspendType"), aname="_suspendType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"resetType"), aname="_resetType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultPowerOffType"), aname="_defaultPowerOffType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultSuspendType"), aname="_defaultSuspendType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultResetType"), aname="_defaultResetType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"standbyAction"), aname="_standbyAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineDefaultPowerOpInfo_Def.__bases__: + bases = list(ns0.VirtualMachineDefaultPowerOpInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineDefaultPowerOpInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineDiskDeviceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineDiskDeviceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineDiskDeviceInfo_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineDiskDeviceInfo_Def.__bases__: + bases = list(ns0.VirtualMachineDiskDeviceInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineDiskDeviceInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultToleranceConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultToleranceConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultToleranceConfigInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuids"), aname="_instanceUuids", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configPaths"), aname="_configPaths", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.FaultToleranceConfigInfo_Def.__bases__: + bases = list(ns0.FaultToleranceConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.FaultToleranceConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultTolerancePrimaryConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultTolerancePrimaryConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultTolerancePrimaryConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"secondaries"), aname="_secondaries", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FaultToleranceConfigInfo_Def not in ns0.FaultTolerancePrimaryConfigInfo_Def.__bases__: + bases = list(ns0.FaultTolerancePrimaryConfigInfo_Def.__bases__) + bases.insert(0, ns0.FaultToleranceConfigInfo_Def) + ns0.FaultTolerancePrimaryConfigInfo_Def.__bases__ = tuple(bases) + + ns0.FaultToleranceConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultToleranceSecondaryConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultToleranceSecondaryConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultToleranceSecondaryConfigInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"primaryVM"), aname="_primaryVM", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.FaultToleranceConfigInfo_Def not in ns0.FaultToleranceSecondaryConfigInfo_Def.__bases__: + bases = list(ns0.FaultToleranceSecondaryConfigInfo_Def.__bases__) + bases.insert(0, ns0.FaultToleranceConfigInfo_Def) + ns0.FaultToleranceSecondaryConfigInfo_Def.__bases__ = tuple(bases) + + ns0.FaultToleranceConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class FaultToleranceSecondaryOpResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "FaultToleranceSecondaryOpResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.FaultToleranceSecondaryOpResult_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"powerOnAttempted"), aname="_powerOnAttempted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterPowerOnVmResult",lazy=True)(pname=(ns,"powerOnResult"), aname="_powerOnResult", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.FaultToleranceSecondaryOpResult_Def.__bases__: + bases = list(ns0.FaultToleranceSecondaryOpResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.FaultToleranceSecondaryOpResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"vmPathName"), aname="_vmPathName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"snapshotDirectory"), aname="_snapshotDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"suspendDirectory"), aname="_suspendDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"logDirectory"), aname="_logDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileInfo_Def.__bases__: + bases = list(ns0.VirtualMachineFileInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineFileLayoutDiskLayout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutDiskLayout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayoutDiskLayout_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskFile"), aname="_diskFile", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutDiskLayout_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayoutDiskLayout_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayoutDiskLayout_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineFileLayoutDiskLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineFileLayoutDiskLayout") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineFileLayoutDiskLayout_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFileLayoutDiskLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutDiskLayout"), aname="_VirtualMachineFileLayoutDiskLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineFileLayoutDiskLayout = [] + return + Holder.__name__ = "ArrayOfVirtualMachineFileLayoutDiskLayout_Holder" + self.pyclass = Holder + + class VirtualMachineFileLayoutSnapshotLayout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutSnapshotLayout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayoutSnapshotLayout_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"snapshotFile"), aname="_snapshotFile", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutSnapshotLayout_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayoutSnapshotLayout_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayoutSnapshotLayout_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineFileLayoutSnapshotLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineFileLayoutSnapshotLayout") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineFileLayoutSnapshotLayout_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFileLayoutSnapshotLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutSnapshotLayout"), aname="_VirtualMachineFileLayoutSnapshotLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineFileLayoutSnapshotLayout = [] + return + Holder.__name__ = "ArrayOfVirtualMachineFileLayoutSnapshotLayout_Holder" + self.pyclass = Holder + + class VirtualMachineFileLayout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayout_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"configFile"), aname="_configFile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"logFile"), aname="_logFile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutDiskLayout",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutSnapshotLayout",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"swapFile"), aname="_swapFile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayout_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayout_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayout_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineFileLayoutExFileType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutExFileType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineFileLayoutExFileInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutExFileInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayoutExFileInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExFileInfo_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayoutExFileInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayoutExFileInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineFileLayoutExFileInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineFileLayoutExFileInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineFileLayoutExFileInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExFileInfo",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExFileInfo"), aname="_VirtualMachineFileLayoutExFileInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineFileLayoutExFileInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExFileInfo_Holder" + self.pyclass = Holder + + class VirtualMachineFileLayoutExDiskUnit_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutExDiskUnit") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayoutExDiskUnit_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"fileKey"), aname="_fileKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExDiskUnit_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayoutExDiskUnit_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayoutExDiskUnit_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineFileLayoutExDiskUnit_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineFileLayoutExDiskUnit") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineFileLayoutExDiskUnit_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExDiskUnit",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExDiskUnit"), aname="_VirtualMachineFileLayoutExDiskUnit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineFileLayoutExDiskUnit = [] + return + Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExDiskUnit_Holder" + self.pyclass = Holder + + class VirtualMachineFileLayoutExDiskLayout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutExDiskLayout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayoutExDiskLayout_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExDiskUnit",lazy=True)(pname=(ns,"chain"), aname="_chain", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExDiskLayout_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayoutExDiskLayout_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayoutExDiskLayout_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineFileLayoutExDiskLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineFileLayoutExDiskLayout") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineFileLayoutExDiskLayout_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExDiskLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExDiskLayout"), aname="_VirtualMachineFileLayoutExDiskLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineFileLayoutExDiskLayout = [] + return + Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExDiskLayout_Holder" + self.pyclass = Holder + + class VirtualMachineFileLayoutExSnapshotLayout_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutExSnapshotLayout") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dataKey"), aname="_dataKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExDiskLayout",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineFileLayoutExSnapshotLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineFileLayoutExSnapshotLayout") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineFileLayoutExSnapshotLayout_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExSnapshotLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExSnapshotLayout"), aname="_VirtualMachineFileLayoutExSnapshotLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineFileLayoutExSnapshotLayout = [] + return + Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExSnapshotLayout_Holder" + self.pyclass = Holder + + class VirtualMachineFileLayoutEx_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFileLayoutEx") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFileLayoutEx_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExFileInfo",lazy=True)(pname=(ns,"file"), aname="_file", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExDiskLayout",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExSnapshotLayout",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutEx_Def.__bases__: + bases = list(ns0.VirtualMachineFileLayoutEx_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFileLayoutEx_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineHtSharing_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineHtSharing") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachinePowerOffBehavior_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachinePowerOffBehavior") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineFlagInfoMonitorType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineFlagInfoMonitorType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineFlagInfoVirtualMmuUsage_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineFlagInfoVirtualMmuUsage") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineFlagInfoVirtualExecUsage_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineFlagInfoVirtualExecUsage") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineFlagInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFlagInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFlagInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"disableAcceleration"), aname="_disableAcceleration", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enableLogging"), aname="_enableLogging", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useToe"), aname="_useToe", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"runWithDebugInfo"), aname="_runWithDebugInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"monitorType"), aname="_monitorType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"htSharing"), aname="_htSharing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"snapshotDisabled"), aname="_snapshotDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"snapshotLocked"), aname="_snapshotLocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"diskUuidEnabled"), aname="_diskUuidEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"virtualMmuUsage"), aname="_virtualMmuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"virtualExecUsage"), aname="_virtualExecUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"snapshotPowerOffBehavior"), aname="_snapshotPowerOffBehavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recordReplayEnabled"), aname="_recordReplayEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineFlagInfo_Def.__bases__: + bases = list(ns0.VirtualMachineFlagInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineFlagInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineFloppyInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineFloppyInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineFloppyInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineFloppyInfo_Def.__bases__: + bases = list(ns0.VirtualMachineFloppyInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineFloppyInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineFloppyInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineFloppyInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineFloppyInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineFloppyInfo",lazy=True)(pname=(ns,"VirtualMachineFloppyInfo"), aname="_VirtualMachineFloppyInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineFloppyInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineFloppyInfo_Holder" + self.pyclass = Holder + + class VirtualMachineToolsStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineToolsStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineToolsVersionStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineToolsVersionStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineToolsRunningStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineToolsRunningStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class GuestDiskInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GuestDiskInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GuestDiskInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskPath"), aname="_diskPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"freeSpace"), aname="_freeSpace", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.GuestDiskInfo_Def.__bases__: + bases = list(ns0.GuestDiskInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.GuestDiskInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfGuestDiskInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfGuestDiskInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfGuestDiskInfo_Def.schema + TClist = [GTD("urn:vim25","GuestDiskInfo",lazy=True)(pname=(ns,"GuestDiskInfo"), aname="_GuestDiskInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._GuestDiskInfo = [] + return + Holder.__name__ = "ArrayOfGuestDiskInfo_Holder" + self.pyclass = Holder + + class GuestNicInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GuestNicInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GuestNicInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceConfigId"), aname="_deviceConfigId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.GuestNicInfo_Def.__bases__: + bases = list(ns0.GuestNicInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.GuestNicInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfGuestNicInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfGuestNicInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfGuestNicInfo_Def.schema + TClist = [GTD("urn:vim25","GuestNicInfo",lazy=True)(pname=(ns,"GuestNicInfo"), aname="_GuestNicInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._GuestNicInfo = [] + return + Holder.__name__ = "ArrayOfGuestNicInfo_Holder" + self.pyclass = Holder + + class GuestScreenInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GuestScreenInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GuestScreenInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.GuestScreenInfo_Def.__bases__: + bases = list(ns0.GuestScreenInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.GuestScreenInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineGuestState_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineGuestState") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class GuestInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GuestInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GuestInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineToolsStatus",lazy=True)(pname=(ns,"toolsStatus"), aname="_toolsStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsVersionStatus"), aname="_toolsVersionStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsRunningStatus"), aname="_toolsRunningStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsVersion"), aname="_toolsVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFamily"), aname="_guestFamily", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestNicInfo",lazy=True)(pname=(ns,"net"), aname="_net", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestDiskInfo",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestScreenInfo",lazy=True)(pname=(ns,"screen"), aname="_screen", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestState"), aname="_guestState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.GuestInfo_Def.__bases__: + bases = list(ns0.GuestInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.GuestInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineGuestOsFamily_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineGuestOsFamily") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineGuestOsIdentifier_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineGuestOsIdentifier") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class GuestOsDescriptor_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "GuestOsDescriptor") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.GuestOsDescriptor_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"family"), aname="_family", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedMaxCPUs"), aname="_supportedMaxCPUs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedMinMemMB"), aname="_supportedMinMemMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedMaxMemMB"), aname="_supportedMaxMemMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"recommendedMemMB"), aname="_recommendedMemMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"recommendedColorDepth"), aname="_recommendedColorDepth", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedDiskControllerList"), aname="_supportedDiskControllerList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"recommendedSCSIController"), aname="_recommendedSCSIController", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"recommendedDiskController"), aname="_recommendedDiskController", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedNumDisks"), aname="_supportedNumDisks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"recommendedDiskSizeMB"), aname="_recommendedDiskSizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedEthernetCard"), aname="_supportedEthernetCard", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"recommendedEthernetCard"), aname="_recommendedEthernetCard", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsSlaveDisk"), aname="_supportsSlaveDisk", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeatureMask"), aname="_cpuFeatureMask", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsWakeOnLan"), aname="_supportsWakeOnLan", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsVMI"), aname="_supportsVMI", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsMemoryHotAdd"), aname="_supportsMemoryHotAdd", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsCpuHotAdd"), aname="_supportsCpuHotAdd", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsCpuHotRemove"), aname="_supportsCpuHotRemove", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.GuestOsDescriptor_Def.__bases__: + bases = list(ns0.GuestOsDescriptor_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.GuestOsDescriptor_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfGuestOsDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfGuestOsDescriptor") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfGuestOsDescriptor_Def.schema + TClist = [GTD("urn:vim25","GuestOsDescriptor",lazy=True)(pname=(ns,"GuestOsDescriptor"), aname="_GuestOsDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._GuestOsDescriptor = [] + return + Holder.__name__ = "ArrayOfGuestOsDescriptor_Holder" + self.pyclass = Holder + + class VirtualMachineIdeDiskDevicePartitionInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineIdeDiskDevicePartitionInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.__bases__: + bases = list(ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineIdeDiskDevicePartitionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineIdeDiskDevicePartitionInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineIdeDiskDevicePartitionInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineIdeDiskDevicePartitionInfo",lazy=True)(pname=(ns,"VirtualMachineIdeDiskDevicePartitionInfo"), aname="_VirtualMachineIdeDiskDevicePartitionInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineIdeDiskDevicePartitionInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineIdeDiskDevicePartitionInfo_Holder" + self.pyclass = Holder + + class VirtualMachineIdeDiskDeviceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineIdeDiskDeviceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineIdeDiskDeviceInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineIdeDiskDevicePartitionInfo",lazy=True)(pname=(ns,"partitionTable"), aname="_partitionTable", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineDiskDeviceInfo_Def not in ns0.VirtualMachineIdeDiskDeviceInfo_Def.__bases__: + bases = list(ns0.VirtualMachineIdeDiskDeviceInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineDiskDeviceInfo_Def) + ns0.VirtualMachineIdeDiskDeviceInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineDiskDeviceInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineIdeDiskDeviceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineIdeDiskDeviceInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineIdeDiskDeviceInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineIdeDiskDeviceInfo",lazy=True)(pname=(ns,"VirtualMachineIdeDiskDeviceInfo"), aname="_VirtualMachineIdeDiskDeviceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineIdeDiskDeviceInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineIdeDiskDeviceInfo_Holder" + self.pyclass = Holder + + class VirtualMachineLegacyNetworkSwitchInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineLegacyNetworkSwitchInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.__bases__: + bases = list(ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineLegacyNetworkSwitchInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineLegacyNetworkSwitchInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineLegacyNetworkSwitchInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineLegacyNetworkSwitchInfo",lazy=True)(pname=(ns,"VirtualMachineLegacyNetworkSwitchInfo"), aname="_VirtualMachineLegacyNetworkSwitchInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineLegacyNetworkSwitchInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineLegacyNetworkSwitchInfo_Holder" + self.pyclass = Holder + + class VirtualMachineMessage_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineMessage") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineMessage_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"text"), aname="_text", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineMessage_Def.__bases__: + bases = list(ns0.VirtualMachineMessage_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineMessage_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineMessage_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineMessage") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineMessage_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"VirtualMachineMessage"), aname="_VirtualMachineMessage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineMessage = [] + return + Holder.__name__ = "ArrayOfVirtualMachineMessage_Holder" + self.pyclass = Holder + + class VirtualMachineNetworkInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineNetworkInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineNetworkInfo_Def.schema + TClist = [GTD("urn:vim25","NetworkSummary",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineNetworkInfo_Def.__bases__: + bases = list(ns0.VirtualMachineNetworkInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineNetworkInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineNetworkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineNetworkInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineNetworkInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineNetworkInfo",lazy=True)(pname=(ns,"VirtualMachineNetworkInfo"), aname="_VirtualMachineNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineNetworkInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineNetworkInfo_Holder" + self.pyclass = Holder + + class VirtualMachineNetworkShaperInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineNetworkShaperInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineNetworkShaperInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"peakBps"), aname="_peakBps", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"averageBps"), aname="_averageBps", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"burstSize"), aname="_burstSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineNetworkShaperInfo_Def.__bases__: + bases = list(ns0.VirtualMachineNetworkShaperInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineNetworkShaperInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineParallelInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineParallelInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineParallelInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineParallelInfo_Def.__bases__: + bases = list(ns0.VirtualMachineParallelInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineParallelInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineParallelInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineParallelInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineParallelInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineParallelInfo",lazy=True)(pname=(ns,"VirtualMachineParallelInfo"), aname="_VirtualMachineParallelInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineParallelInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineParallelInfo_Holder" + self.pyclass = Holder + + class VirtualMachinePciPassthroughInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachinePciPassthroughInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachinePciPassthroughInfo_Def.schema + TClist = [GTD("urn:vim25","HostPciDevice",lazy=True)(pname=(ns,"pciDevice"), aname="_pciDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemId"), aname="_systemId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachinePciPassthroughInfo_Def.__bases__: + bases = list(ns0.VirtualMachinePciPassthroughInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachinePciPassthroughInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachinePciPassthroughInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachinePciPassthroughInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachinePciPassthroughInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachinePciPassthroughInfo",lazy=True)(pname=(ns,"VirtualMachinePciPassthroughInfo"), aname="_VirtualMachinePciPassthroughInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachinePciPassthroughInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachinePciPassthroughInfo_Holder" + self.pyclass = Holder + + class VirtualMachineQuestionInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineQuestionInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineQuestionInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"text"), aname="_text", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"choice"), aname="_choice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineQuestionInfo_Def.__bases__: + bases = list(ns0.VirtualMachineQuestionInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineQuestionInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineRelocateTransformation_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineRelocateTransformation") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineRelocateSpecDiskLocator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineRelocateSpecDiskLocator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineRelocateSpecDiskLocator_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"diskId"), aname="_diskId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskMoveType"), aname="_diskMoveType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineRelocateSpecDiskLocator_Def.__bases__: + bases = list(ns0.VirtualMachineRelocateSpecDiskLocator_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineRelocateSpecDiskLocator_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineRelocateSpecDiskLocator_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineRelocateSpecDiskLocator") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineRelocateSpecDiskLocator_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineRelocateSpecDiskLocator",lazy=True)(pname=(ns,"VirtualMachineRelocateSpecDiskLocator"), aname="_VirtualMachineRelocateSpecDiskLocator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineRelocateSpecDiskLocator = [] + return + Holder.__name__ = "ArrayOfVirtualMachineRelocateSpecDiskLocator_Holder" + self.pyclass = Holder + + class VirtualMachineRelocateDiskMoveOptions_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineRelocateDiskMoveOptions") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineRelocateSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineRelocateSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineRelocateSpec_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskMoveType"), aname="_diskMoveType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateSpecDiskLocator",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateTransformation",lazy=True)(pname=(ns,"transform"), aname="_transform", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineRelocateSpec_Def.__bases__: + bases = list(ns0.VirtualMachineRelocateSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineRelocateSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineRuntimeInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineRuntimeInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineRuntimeInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConnectionState",lazy=True)(pname=(ns,"connectionState"), aname="_connectionState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"powerState"), aname="_powerState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFaultToleranceState",lazy=True)(pname=(ns,"faultToleranceState"), aname="_faultToleranceState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"toolsInstallerMounted"), aname="_toolsInstallerMounted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"suspendTime"), aname="_suspendTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"bootTime"), aname="_bootTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"suspendInterval"), aname="_suspendInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineQuestionInfo",lazy=True)(pname=(ns,"question"), aname="_question", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryOverhead"), aname="_memoryOverhead", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCpuUsage"), aname="_maxCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemoryUsage"), aname="_maxMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numMksConnections"), aname="_numMksConnections", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRecordReplayState",lazy=True)(pname=(ns,"recordReplayState"), aname="_recordReplayState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cleanPowerOff"), aname="_cleanPowerOff", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"needSecondaryReason"), aname="_needSecondaryReason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineRuntimeInfo_Def.__bases__: + bases = list(ns0.VirtualMachineRuntimeInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineRuntimeInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineScsiDiskDeviceInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineScsiDiskDeviceInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineScsiDiskDeviceInfo_Def.schema + TClist = [GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"transportHint"), aname="_transportHint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lunNumber"), aname="_lunNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineDiskDeviceInfo_Def not in ns0.VirtualMachineScsiDiskDeviceInfo_Def.__bases__: + bases = list(ns0.VirtualMachineScsiDiskDeviceInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineDiskDeviceInfo_Def) + ns0.VirtualMachineScsiDiskDeviceInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineDiskDeviceInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineScsiDiskDeviceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineScsiDiskDeviceInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineScsiDiskDeviceInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineScsiDiskDeviceInfo",lazy=True)(pname=(ns,"VirtualMachineScsiDiskDeviceInfo"), aname="_VirtualMachineScsiDiskDeviceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineScsiDiskDeviceInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineScsiDiskDeviceInfo_Holder" + self.pyclass = Holder + + class VirtualMachineScsiPassthroughType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineScsiPassthroughType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineScsiPassthroughInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineScsiPassthroughInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineScsiPassthroughInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"scsiClass"), aname="_scsiClass", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"physicalUnitNumber"), aname="_physicalUnitNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineScsiPassthroughInfo_Def.__bases__: + bases = list(ns0.VirtualMachineScsiPassthroughInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineScsiPassthroughInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineScsiPassthroughInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineScsiPassthroughInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineScsiPassthroughInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineScsiPassthroughInfo",lazy=True)(pname=(ns,"VirtualMachineScsiPassthroughInfo"), aname="_VirtualMachineScsiPassthroughInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineScsiPassthroughInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineScsiPassthroughInfo_Holder" + self.pyclass = Holder + + class VirtualMachineSerialInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineSerialInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineSerialInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineSerialInfo_Def.__bases__: + bases = list(ns0.VirtualMachineSerialInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineSerialInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineSerialInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineSerialInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineSerialInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineSerialInfo",lazy=True)(pname=(ns,"VirtualMachineSerialInfo"), aname="_VirtualMachineSerialInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineSerialInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineSerialInfo_Holder" + self.pyclass = Holder + + class RevertToSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RevertToSnapshotRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RevertToSnapshotRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suppressPowerOn"), aname="_suppressPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._host = None + self._suppressPowerOn = None + return + Holder.__name__ = "RevertToSnapshotRequestType_Holder" + self.pyclass = Holder + + class RemoveSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RemoveSnapshotRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RemoveSnapshotRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"removeChildren"), aname="_removeChildren", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._removeChildren = None + return + Holder.__name__ = "RemoveSnapshotRequestType_Holder" + self.pyclass = Holder + + class RenameSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "RenameSnapshotRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.RenameSnapshotRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._name = None + self._description = None + return + Holder.__name__ = "RenameSnapshotRequestType_Holder" + self.pyclass = Holder + + class VirtualMachineSnapshotInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineSnapshotInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineSnapshotInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"currentSnapshot"), aname="_currentSnapshot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSnapshotTree",lazy=True)(pname=(ns,"rootSnapshotList"), aname="_rootSnapshotList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineSnapshotInfo_Def.__bases__: + bases = list(ns0.VirtualMachineSnapshotInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineSnapshotInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineSnapshotTree_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineSnapshotTree") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineSnapshotTree_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"createTime"), aname="_createTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"quiesced"), aname="_quiesced", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backupManifest"), aname="_backupManifest", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSnapshotTree",lazy=True)(pname=(ns,"childSnapshotList"), aname="_childSnapshotList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"replaySupported"), aname="_replaySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineSnapshotTree_Def.__bases__: + bases = list(ns0.VirtualMachineSnapshotTree_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineSnapshotTree_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineSnapshotTree_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineSnapshotTree") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineSnapshotTree_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineSnapshotTree",lazy=True)(pname=(ns,"VirtualMachineSnapshotTree"), aname="_VirtualMachineSnapshotTree", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineSnapshotTree = [] + return + Holder.__name__ = "ArrayOfVirtualMachineSnapshotTree_Holder" + self.pyclass = Holder + + class VirtualMachineSoundInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineSoundInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineSoundInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineSoundInfo_Def.__bases__: + bases = list(ns0.VirtualMachineSoundInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineSoundInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineSoundInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineSoundInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineSoundInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineSoundInfo",lazy=True)(pname=(ns,"VirtualMachineSoundInfo"), aname="_VirtualMachineSoundInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineSoundInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineSoundInfo_Holder" + self.pyclass = Holder + + class VirtualMachineUsageOnDatastore_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineUsageOnDatastore") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineUsageOnDatastore_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"committed"), aname="_committed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"uncommitted"), aname="_uncommitted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unshared"), aname="_unshared", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineUsageOnDatastore_Def.__bases__: + bases = list(ns0.VirtualMachineUsageOnDatastore_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineUsageOnDatastore_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineUsageOnDatastore_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineUsageOnDatastore") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineUsageOnDatastore_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineUsageOnDatastore",lazy=True)(pname=(ns,"VirtualMachineUsageOnDatastore"), aname="_VirtualMachineUsageOnDatastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineUsageOnDatastore = [] + return + Holder.__name__ = "ArrayOfVirtualMachineUsageOnDatastore_Holder" + self.pyclass = Holder + + class VirtualMachineStorageInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineStorageInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineStorageInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineUsageOnDatastore",lazy=True)(pname=(ns,"perDatastoreUsage"), aname="_perDatastoreUsage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineStorageInfo_Def.__bases__: + bases = list(ns0.VirtualMachineStorageInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineStorageInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineConfigSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineConfigSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineConfigSummary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmPathName"), aname="_vmPathName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memorySizeMB"), aname="_memorySizeMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuReservation"), aname="_cpuReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryReservation"), aname="_memoryReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpu"), aname="_numCpu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numEthernetCards"), aname="_numEthernetCards", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVirtualDisks"), aname="_numVirtualDisks", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FaultToleranceConfigInfo",lazy=True)(pname=(ns,"ftInfo"), aname="_ftInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineConfigSummary_Def.__bases__: + bases = list(ns0.VirtualMachineConfigSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineConfigSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineQuickStats_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineQuickStats") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineQuickStats_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"overallCpuUsage"), aname="_overallCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"overallCpuDemand"), aname="_overallCpuDemand", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"guestMemoryUsage"), aname="_guestMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostMemoryUsage"), aname="_hostMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"guestHeartbeatStatus"), aname="_guestHeartbeatStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedCpuEntitlement"), aname="_distributedCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedMemoryEntitlement"), aname="_distributedMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticCpuEntitlement"), aname="_staticCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticMemoryEntitlement"), aname="_staticMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"privateMemory"), aname="_privateMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"sharedMemory"), aname="_sharedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"swappedMemory"), aname="_swappedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"balloonedMemory"), aname="_balloonedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"consumedOverheadMemory"), aname="_consumedOverheadMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ftLogBandwidth"), aname="_ftLogBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ftSecondaryLatency"), aname="_ftSecondaryLatency", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"ftLatencyStatus"), aname="_ftLatencyStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineQuickStats_Def.__bases__: + bases = list(ns0.VirtualMachineQuickStats_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineQuickStats_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineGuestSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineGuestSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineGuestSummary_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineToolsStatus",lazy=True)(pname=(ns,"toolsStatus"), aname="_toolsStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsVersionStatus"), aname="_toolsVersionStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsRunningStatus"), aname="_toolsRunningStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineGuestSummary_Def.__bases__: + bases = list(ns0.VirtualMachineGuestSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineGuestSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineStorageSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineStorageSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineStorageSummary_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"committed"), aname="_committed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"uncommitted"), aname="_uncommitted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unshared"), aname="_unshared", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineStorageSummary_Def.__bases__: + bases = list(ns0.VirtualMachineStorageSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineStorageSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineSummary_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineSummary") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineSummary_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRuntimeInfo",lazy=True)(pname=(ns,"runtime"), aname="_runtime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineGuestSummary",lazy=True)(pname=(ns,"guest"), aname="_guest", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSummary",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineStorageSummary",lazy=True)(pname=(ns,"storage"), aname="_storage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineQuickStats",lazy=True)(pname=(ns,"quickStats"), aname="_quickStats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomFieldValue",lazy=True)(pname=(ns,"customValue"), aname="_customValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineSummary_Def.__bases__: + bases = list(ns0.VirtualMachineSummary_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineSummary_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineSummary_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineSummary") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineSummary_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineSummary",lazy=True)(pname=(ns,"VirtualMachineSummary"), aname="_VirtualMachineSummary", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineSummary = [] + return + Holder.__name__ = "ArrayOfVirtualMachineSummary_Holder" + self.pyclass = Holder + + class VirtualMachineTargetInfoConfigurationTag_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineTargetInfoConfigurationTag") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineTargetInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineTargetInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineTargetInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configurationTag"), aname="_configurationTag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualMachineTargetInfo_Def.__bases__: + bases = list(ns0.VirtualMachineTargetInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualMachineTargetInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class UpgradePolicy_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "UpgradePolicy") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ToolsConfigInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ToolsConfigInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ToolsConfigInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"toolsVersion"), aname="_toolsVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"afterPowerOn"), aname="_afterPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"afterResume"), aname="_afterResume", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"beforeGuestStandby"), aname="_beforeGuestStandby", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"beforeGuestShutdown"), aname="_beforeGuestShutdown", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"beforeGuestReboot"), aname="_beforeGuestReboot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsUpgradePolicy"), aname="_toolsUpgradePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pendingCustomization"), aname="_pendingCustomization", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"syncTimeWithHost"), aname="_syncTimeWithHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.ToolsConfigInfo_Def.__bases__: + bases = list(ns0.ToolsConfigInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.ToolsConfigInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineUsbInfoSpeed_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineUsbInfoSpeed") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineUsbInfoFamily_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualMachineUsbInfoFamily") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualMachineUsbInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineUsbInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineUsbInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"product"), aname="_product", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"physicalPath"), aname="_physicalPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"family"), aname="_family", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"speed"), aname="_speed", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSummary",lazy=True)(pname=(ns,"summary"), aname="_summary", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineUsbInfo_Def.__bases__: + bases = list(ns0.VirtualMachineUsbInfo_Def.__bases__) + bases.insert(0, ns0.VirtualMachineTargetInfo_Def) + ns0.VirtualMachineUsbInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualMachineUsbInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualMachineUsbInfo") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualMachineUsbInfo_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineUsbInfo",lazy=True)(pname=(ns,"VirtualMachineUsbInfo"), aname="_VirtualMachineUsbInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualMachineUsbInfo = [] + return + Holder.__name__ = "ArrayOfVirtualMachineUsbInfo_Holder" + self.pyclass = Holder + + class VirtualHardware_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualHardware") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualHardware_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numCPU"), aname="_numCPU", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualHardware_Def.__bases__: + bases = list(ns0.VirtualHardware_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualHardware_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualHardwareOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualHardwareOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualHardwareOption_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"hwVersion"), aname="_hwVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceOption",lazy=True)(pname=(ns,"virtualDeviceOption"), aname="_virtualDeviceOption", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deviceListReadonly"), aname="_deviceListReadonly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCPU"), aname="_numCPU", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"numCpuReadonly"), aname="_numCpuReadonly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongOption",lazy=True)(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPCIControllers"), aname="_numPCIControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numIDEControllers"), aname="_numIDEControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numUSBControllers"), aname="_numUSBControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSIOControllers"), aname="_numSIOControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPS2Controllers"), aname="_numPS2Controllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licensingLimit"), aname="_licensingLimit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSupportedWwnPorts"), aname="_numSupportedWwnPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSupportedWwnNodes"), aname="_numSupportedWwnNodes", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualHardwareOption_Def.__bases__: + bases = list(ns0.VirtualHardwareOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualHardwareOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineImportSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineImportSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineImportSpec_Def.schema + TClist = [GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.ImportSpec_Def not in ns0.VirtualMachineImportSpec_Def.__bases__: + bases = list(ns0.VirtualMachineImportSpec_Def.__bases__) + bases.insert(0, ns0.ImportSpec_Def) + ns0.VirtualMachineImportSpec_Def.__bases__ = tuple(bases) + + ns0.ImportSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CheckCompatibilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckCompatibilityRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckCompatibilityRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + self._host = None + self._pool = None + self._testType = [] + return + Holder.__name__ = "CheckCompatibilityRequestType_Holder" + self.pyclass = Holder + + class QueryVMotionCompatibilityExRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "QueryVMotionCompatibilityExRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.QueryVMotionCompatibilityExRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = [] + self._host = [] + return + Holder.__name__ = "QueryVMotionCompatibilityExRequestType_Holder" + self.pyclass = Holder + + class CheckMigrateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckMigrateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckMigrateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + self._host = None + self._pool = None + self._state = None + self._testType = [] + return + Holder.__name__ = "CheckMigrateRequestType_Holder" + self.pyclass = Holder + + class CheckRelocateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckRelocateRequestType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.CheckRelocateRequestType_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self.__this = None + self._vm = None + self._spec = None + self._testType = [] + return + Holder.__name__ = "CheckRelocateRequestType_Holder" + self.pyclass = Holder + + class CheckResult_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CheckResult") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CheckResult_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CheckResult_Def.__bases__: + bases = list(ns0.CheckResult_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CheckResult_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfCheckResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfCheckResult") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfCheckResult_Def.schema + TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"CheckResult"), aname="_CheckResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._CheckResult = [] + return + Holder.__name__ = "ArrayOfCheckResult_Holder" + self.pyclass = Holder + + class CheckTestType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CheckTestType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class CustomizationSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationSpec_Def.schema + TClist = [GTD("urn:vim25","CustomizationOptions",lazy=True)(pname=(ns,"options"), aname="_options", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIdentitySettings",lazy=True)(pname=(ns,"identity"), aname="_identity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationGlobalIPSettings",lazy=True)(pname=(ns,"globalIPSettings"), aname="_globalIPSettings", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationAdapterMapping",lazy=True)(pname=(ns,"nicSettingMap"), aname="_nicSettingMap", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"encryptionKey"), aname="_encryptionKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationSpec_Def.__bases__: + bases = list(ns0.CustomizationSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationName_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationName_Def.__bases__: + bases = list(ns0.CustomizationName_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationName_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationFixedName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationFixedName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationFixedName_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationName_Def not in ns0.CustomizationFixedName_Def.__bases__: + bases = list(ns0.CustomizationFixedName_Def.__bases__) + bases.insert(0, ns0.CustomizationName_Def) + ns0.CustomizationFixedName_Def.__bases__ = tuple(bases) + + ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationPrefixName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationPrefixName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationPrefixName_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"base"), aname="_base", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationName_Def not in ns0.CustomizationPrefixName_Def.__bases__: + bases = list(ns0.CustomizationPrefixName_Def.__bases__) + bases.insert(0, ns0.CustomizationName_Def) + ns0.CustomizationPrefixName_Def.__bases__ = tuple(bases) + + ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationVirtualMachineName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationVirtualMachineName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationVirtualMachineName_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationName_Def not in ns0.CustomizationVirtualMachineName_Def.__bases__: + bases = list(ns0.CustomizationVirtualMachineName_Def.__bases__) + bases.insert(0, ns0.CustomizationName_Def) + ns0.CustomizationVirtualMachineName_Def.__bases__ = tuple(bases) + + ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationUnknownName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationUnknownName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationUnknownName_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationName_Def not in ns0.CustomizationUnknownName_Def.__bases__: + bases = list(ns0.CustomizationUnknownName_Def.__bases__) + bases.insert(0, ns0.CustomizationName_Def) + ns0.CustomizationUnknownName_Def.__bases__ = tuple(bases) + + ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationCustomName_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationCustomName") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationCustomName_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationName_Def not in ns0.CustomizationCustomName_Def.__bases__: + bases = list(ns0.CustomizationCustomName_Def.__bases__) + bases.insert(0, ns0.CustomizationName_Def) + ns0.CustomizationCustomName_Def.__bases__ = tuple(bases) + + ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationPassword_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationPassword") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationPassword_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"plainText"), aname="_plainText", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationPassword_Def.__bases__: + bases = list(ns0.CustomizationPassword_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationPassword_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationOptions_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationOptions") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationOptions_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationOptions_Def.__bases__: + bases = list(ns0.CustomizationOptions_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationOptions_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationSysprepRebootOption_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CustomizationSysprepRebootOption") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class CustomizationWinOptions_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationWinOptions") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationWinOptions_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"changeSID"), aname="_changeSID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deleteAccounts"), aname="_deleteAccounts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSysprepRebootOption",lazy=True)(pname=(ns,"reboot"), aname="_reboot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationOptions_Def not in ns0.CustomizationWinOptions_Def.__bases__: + bases = list(ns0.CustomizationWinOptions_Def.__bases__) + bases.insert(0, ns0.CustomizationOptions_Def) + ns0.CustomizationWinOptions_Def.__bases__ = tuple(bases) + + ns0.CustomizationOptions_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationLinuxOptions_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationLinuxOptions") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationLinuxOptions_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationOptions_Def not in ns0.CustomizationLinuxOptions_Def.__bases__: + bases = list(ns0.CustomizationLinuxOptions_Def.__bases__) + bases.insert(0, ns0.CustomizationOptions_Def) + ns0.CustomizationLinuxOptions_Def.__bases__ = tuple(bases) + + ns0.CustomizationOptions_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationGuiUnattended_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationGuiUnattended") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationGuiUnattended_Def.schema + TClist = [GTD("urn:vim25","CustomizationPassword",lazy=True)(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoLogon"), aname="_autoLogon", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"autoLogonCount"), aname="_autoLogonCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationGuiUnattended_Def.__bases__: + bases = list(ns0.CustomizationGuiUnattended_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationGuiUnattended_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationUserData_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationUserData") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationUserData_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"orgName"), aname="_orgName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationName",lazy=True)(pname=(ns,"computerName"), aname="_computerName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productId"), aname="_productId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationUserData_Def.__bases__: + bases = list(ns0.CustomizationUserData_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationUserData_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationGuiRunOnce_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationGuiRunOnce") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationGuiRunOnce_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"commandList"), aname="_commandList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationGuiRunOnce_Def.__bases__: + bases = list(ns0.CustomizationGuiRunOnce_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationGuiRunOnce_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationIdentification_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationIdentification") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationIdentification_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"joinWorkgroup"), aname="_joinWorkgroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"joinDomain"), aname="_joinDomain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domainAdmin"), aname="_domainAdmin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationPassword",lazy=True)(pname=(ns,"domainAdminPassword"), aname="_domainAdminPassword", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationIdentification_Def.__bases__: + bases = list(ns0.CustomizationIdentification_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationIdentification_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationLicenseDataMode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CustomizationLicenseDataMode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class CustomizationLicenseFilePrintData_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationLicenseFilePrintData") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationLicenseFilePrintData_Def.schema + TClist = [GTD("urn:vim25","CustomizationLicenseDataMode",lazy=True)(pname=(ns,"autoMode"), aname="_autoMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"autoUsers"), aname="_autoUsers", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationLicenseFilePrintData_Def.__bases__: + bases = list(ns0.CustomizationLicenseFilePrintData_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationLicenseFilePrintData_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationIdentitySettings_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationIdentitySettings") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationIdentitySettings_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationIdentitySettings_Def.__bases__: + bases = list(ns0.CustomizationIdentitySettings_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationIdentitySettings_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationSysprepText_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationSysprepText") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationSysprepText_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIdentitySettings_Def not in ns0.CustomizationSysprepText_Def.__bases__: + bases = list(ns0.CustomizationSysprepText_Def.__bases__) + bases.insert(0, ns0.CustomizationIdentitySettings_Def) + ns0.CustomizationSysprepText_Def.__bases__ = tuple(bases) + + ns0.CustomizationIdentitySettings_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationSysprep_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationSysprep") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationSysprep_Def.schema + TClist = [GTD("urn:vim25","CustomizationGuiUnattended",lazy=True)(pname=(ns,"guiUnattended"), aname="_guiUnattended", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationUserData",lazy=True)(pname=(ns,"userData"), aname="_userData", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationGuiRunOnce",lazy=True)(pname=(ns,"guiRunOnce"), aname="_guiRunOnce", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIdentification",lazy=True)(pname=(ns,"identification"), aname="_identification", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationLicenseFilePrintData",lazy=True)(pname=(ns,"licenseFilePrintData"), aname="_licenseFilePrintData", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIdentitySettings_Def not in ns0.CustomizationSysprep_Def.__bases__: + bases = list(ns0.CustomizationSysprep_Def.__bases__) + bases.insert(0, ns0.CustomizationIdentitySettings_Def) + ns0.CustomizationSysprep_Def.__bases__ = tuple(bases) + + ns0.CustomizationIdentitySettings_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationLinuxPrep_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationLinuxPrep") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationLinuxPrep_Def.schema + TClist = [GTD("urn:vim25","CustomizationName",lazy=True)(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domain"), aname="_domain", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hwClockUTC"), aname="_hwClockUTC", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIdentitySettings_Def not in ns0.CustomizationLinuxPrep_Def.__bases__: + bases = list(ns0.CustomizationLinuxPrep_Def.__bases__) + bases.insert(0, ns0.CustomizationIdentitySettings_Def) + ns0.CustomizationLinuxPrep_Def.__bases__ = tuple(bases) + + ns0.CustomizationIdentitySettings_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationGlobalIPSettings_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationGlobalIPSettings") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationGlobalIPSettings_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"dnsSuffixList"), aname="_dnsSuffixList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsServerList"), aname="_dnsServerList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationGlobalIPSettings_Def.__bases__: + bases = list(ns0.CustomizationGlobalIPSettings_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationGlobalIPSettings_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationIPSettingsIpV6AddressSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationIPSettingsIpV6AddressSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationIPSettingsIpV6AddressSpec_Def.schema + TClist = [GTD("urn:vim25","CustomizationIpV6Generator",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationIPSettingsIpV6AddressSpec_Def.__bases__: + bases = list(ns0.CustomizationIPSettingsIpV6AddressSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationIPSettingsIpV6AddressSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationNetBIOSMode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "CustomizationNetBIOSMode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class CustomizationIPSettings_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationIPSettings") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationIPSettings_Def.schema + TClist = [GTD("urn:vim25","CustomizationIpGenerator",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIPSettingsIpV6AddressSpec",lazy=True)(pname=(ns,"ipV6Spec"), aname="_ipV6Spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsServerList"), aname="_dnsServerList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsDomain"), aname="_dnsDomain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"primaryWINS"), aname="_primaryWINS", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"secondaryWINS"), aname="_secondaryWINS", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationNetBIOSMode",lazy=True)(pname=(ns,"netBIOS"), aname="_netBIOS", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationIPSettings_Def.__bases__: + bases = list(ns0.CustomizationIPSettings_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationIPSettings_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationIpGenerator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationIpGenerator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationIpGenerator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationIpGenerator_Def.__bases__: + bases = list(ns0.CustomizationIpGenerator_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationIpGenerator_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationDhcpIpGenerator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationDhcpIpGenerator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationDhcpIpGenerator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationDhcpIpGenerator_Def.__bases__: + bases = list(ns0.CustomizationDhcpIpGenerator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpGenerator_Def) + ns0.CustomizationDhcpIpGenerator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationFixedIp_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationFixedIp") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationFixedIp_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationFixedIp_Def.__bases__: + bases = list(ns0.CustomizationFixedIp_Def.__bases__) + bases.insert(0, ns0.CustomizationIpGenerator_Def) + ns0.CustomizationFixedIp_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationUnknownIpGenerator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationUnknownIpGenerator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationUnknownIpGenerator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationUnknownIpGenerator_Def.__bases__: + bases = list(ns0.CustomizationUnknownIpGenerator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpGenerator_Def) + ns0.CustomizationUnknownIpGenerator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationCustomIpGenerator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationCustomIpGenerator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationCustomIpGenerator_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationCustomIpGenerator_Def.__bases__: + bases = list(ns0.CustomizationCustomIpGenerator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpGenerator_Def) + ns0.CustomizationCustomIpGenerator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationIpV6Generator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationIpV6Generator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationIpV6Generator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationIpV6Generator_Def.__bases__: + bases = list(ns0.CustomizationIpV6Generator_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationIpV6Generator_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfCustomizationIpV6Generator_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfCustomizationIpV6Generator") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfCustomizationIpV6Generator_Def.schema + TClist = [GTD("urn:vim25","CustomizationIpV6Generator",lazy=True)(pname=(ns,"CustomizationIpV6Generator"), aname="_CustomizationIpV6Generator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._CustomizationIpV6Generator = [] + return + Holder.__name__ = "ArrayOfCustomizationIpV6Generator_Holder" + self.pyclass = Holder + + class CustomizationDhcpIpV6Generator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationDhcpIpV6Generator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationDhcpIpV6Generator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationDhcpIpV6Generator_Def.__bases__: + bases = list(ns0.CustomizationDhcpIpV6Generator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpV6Generator_Def) + ns0.CustomizationDhcpIpV6Generator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationStatelessIpV6Generator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationStatelessIpV6Generator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationStatelessIpV6Generator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationStatelessIpV6Generator_Def.__bases__: + bases = list(ns0.CustomizationStatelessIpV6Generator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpV6Generator_Def) + ns0.CustomizationStatelessIpV6Generator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationFixedIpV6_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationFixedIpV6") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationFixedIpV6_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationFixedIpV6_Def.__bases__: + bases = list(ns0.CustomizationFixedIpV6_Def.__bases__) + bases.insert(0, ns0.CustomizationIpV6Generator_Def) + ns0.CustomizationFixedIpV6_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationAutoIpV6Generator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationAutoIpV6Generator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationAutoIpV6Generator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationAutoIpV6Generator_Def.__bases__: + bases = list(ns0.CustomizationAutoIpV6Generator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpV6Generator_Def) + ns0.CustomizationAutoIpV6Generator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationUnknownIpV6Generator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationUnknownIpV6Generator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationUnknownIpV6Generator_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationUnknownIpV6Generator_Def.__bases__: + bases = list(ns0.CustomizationUnknownIpV6Generator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpV6Generator_Def) + ns0.CustomizationUnknownIpV6Generator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationCustomIpV6Generator_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationCustomIpV6Generator") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationCustomIpV6Generator_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationCustomIpV6Generator_Def.__bases__: + bases = list(ns0.CustomizationCustomIpV6Generator_Def.__bases__) + bases.insert(0, ns0.CustomizationIpV6Generator_Def) + ns0.CustomizationCustomIpV6Generator_Def.__bases__ = tuple(bases) + + ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class CustomizationAdapterMapping_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "CustomizationAdapterMapping") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.CustomizationAdapterMapping_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIPSettings",lazy=True)(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.CustomizationAdapterMapping_Def.__bases__: + bases = list(ns0.CustomizationAdapterMapping_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.CustomizationAdapterMapping_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfCustomizationAdapterMapping_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfCustomizationAdapterMapping") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfCustomizationAdapterMapping_Def.schema + TClist = [GTD("urn:vim25","CustomizationAdapterMapping",lazy=True)(pname=(ns,"CustomizationAdapterMapping"), aname="_CustomizationAdapterMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._CustomizationAdapterMapping = [] + return + Holder.__name__ = "ArrayOfCustomizationAdapterMapping_Holder" + self.pyclass = Holder + + class HostDiskMappingPartitionInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskMappingPartitionInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskMappingPartitionInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fileSystem"), aname="_fileSystem", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacityInKb"), aname="_capacityInKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskMappingPartitionInfo_Def.__bases__: + bases = list(ns0.HostDiskMappingPartitionInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskMappingPartitionInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiskMappingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskMappingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskMappingInfo_Def.schema + TClist = [GTD("urn:vim25","HostDiskMappingPartitionInfo",lazy=True)(pname=(ns,"physicalPartition"), aname="_physicalPartition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskMappingInfo_Def.__bases__: + bases = list(ns0.HostDiskMappingInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskMappingInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class HostDiskMappingPartitionOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskMappingPartitionOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskMappingPartitionOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fileSystem"), aname="_fileSystem", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacityInKb"), aname="_capacityInKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskMappingPartitionOption_Def.__bases__: + bases = list(ns0.HostDiskMappingPartitionOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskMappingPartitionOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfHostDiskMappingPartitionOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfHostDiskMappingPartitionOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfHostDiskMappingPartitionOption_Def.schema + TClist = [GTD("urn:vim25","HostDiskMappingPartitionOption",lazy=True)(pname=(ns,"HostDiskMappingPartitionOption"), aname="_HostDiskMappingPartitionOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._HostDiskMappingPartitionOption = [] + return + Holder.__name__ = "ArrayOfHostDiskMappingPartitionOption_Holder" + self.pyclass = Holder + + class HostDiskMappingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "HostDiskMappingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.HostDiskMappingOption_Def.schema + TClist = [GTD("urn:vim25","HostDiskMappingPartitionOption",lazy=True)(pname=(ns,"physicalPartition"), aname="_physicalPartition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.HostDiskMappingOption_Def.__bases__: + bases = list(ns0.HostDiskMappingOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.HostDiskMappingOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ParaVirtualSCSIController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ParaVirtualSCSIController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ParaVirtualSCSIController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIController_Def not in ns0.ParaVirtualSCSIController_Def.__bases__: + bases = list(ns0.ParaVirtualSCSIController_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIController_Def) + ns0.ParaVirtualSCSIController_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ParaVirtualSCSIControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "ParaVirtualSCSIControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.ParaVirtualSCSIControllerOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIControllerOption_Def not in ns0.ParaVirtualSCSIControllerOption_Def.__bases__: + bases = list(ns0.ParaVirtualSCSIControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIControllerOption_Def) + ns0.ParaVirtualSCSIControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualBusLogicController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualBusLogicController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualBusLogicController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIController_Def not in ns0.VirtualBusLogicController_Def.__bases__: + bases = list(ns0.VirtualBusLogicController_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIController_Def) + ns0.VirtualBusLogicController_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualBusLogicControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualBusLogicControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualBusLogicControllerOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIControllerOption_Def not in ns0.VirtualBusLogicControllerOption_Def.__bases__: + bases = list(ns0.VirtualBusLogicControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIControllerOption_Def) + ns0.VirtualBusLogicControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromIsoBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromIsoBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromIsoBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualCdromIsoBackingInfo_Def.__bases__: + bases = list(ns0.VirtualCdromIsoBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualCdromIsoBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromPassthroughBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromPassthroughBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromPassthroughBackingInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualCdromPassthroughBackingInfo_Def.__bases__: + bases = list(ns0.VirtualCdromPassthroughBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualCdromPassthroughBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromRemotePassthroughBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromRemotePassthroughBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromRemotePassthroughBackingInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceRemoteDeviceBackingInfo_Def not in ns0.VirtualCdromRemotePassthroughBackingInfo_Def.__bases__: + bases = list(ns0.VirtualCdromRemotePassthroughBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingInfo_Def) + ns0.VirtualCdromRemotePassthroughBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromAtapiBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromAtapiBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromAtapiBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualCdromAtapiBackingInfo_Def.__bases__: + bases = list(ns0.VirtualCdromAtapiBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualCdromAtapiBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromRemoteAtapiBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromRemoteAtapiBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromRemoteAtapiBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceRemoteDeviceBackingInfo_Def not in ns0.VirtualCdromRemoteAtapiBackingInfo_Def.__bases__: + bases = list(ns0.VirtualCdromRemoteAtapiBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingInfo_Def) + ns0.VirtualCdromRemoteAtapiBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdrom_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdrom") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdrom_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualCdrom_Def.__bases__: + bases = list(ns0.VirtualCdrom_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualCdrom_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromIsoBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromIsoBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromIsoBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualCdromIsoBackingOption_Def.__bases__: + bases = list(ns0.VirtualCdromIsoBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualCdromIsoBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromPassthroughBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromPassthroughBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromPassthroughBackingOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualCdromPassthroughBackingOption_Def.__bases__: + bases = list(ns0.VirtualCdromPassthroughBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualCdromPassthroughBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromRemotePassthroughBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromRemotePassthroughBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromRemotePassthroughBackingOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceRemoteDeviceBackingOption_Def not in ns0.VirtualCdromRemotePassthroughBackingOption_Def.__bases__: + bases = list(ns0.VirtualCdromRemotePassthroughBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingOption_Def) + ns0.VirtualCdromRemotePassthroughBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromAtapiBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromAtapiBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromAtapiBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualCdromAtapiBackingOption_Def.__bases__: + bases = list(ns0.VirtualCdromAtapiBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualCdromAtapiBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromRemoteAtapiBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromRemoteAtapiBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromRemoteAtapiBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualCdromRemoteAtapiBackingOption_Def.__bases__: + bases = list(ns0.VirtualCdromRemoteAtapiBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualCdromRemoteAtapiBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualCdromOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualCdromOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualCdromOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualCdromOption_Def.__bases__: + bases = list(ns0.VirtualCdromOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualCdromOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualController_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"busNumber"), aname="_busNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualController_Def.__bases__: + bases = list(ns0.VirtualController_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualController_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualControllerOption_Def.schema + TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"devices"), aname="_devices", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedDevice"), aname="_supportedDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualControllerOption_Def.__bases__: + bases = list(ns0.VirtualControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceFileBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceFileBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceFileBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"fileName"), aname="_fileName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDeviceFileBackingInfo_Def.__bases__: + bases = list(ns0.VirtualDeviceFileBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) + ns0.VirtualDeviceFileBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceDeviceBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDeviceDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualDeviceDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) + ns0.VirtualDeviceDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceRemoteDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceRemoteDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) + ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDevicePipeBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDevicePipeBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDevicePipeBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"pipeName"), aname="_pipeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDevicePipeBackingInfo_Def.__bases__: + bases = list(ns0.VirtualDevicePipeBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) + ns0.VirtualDevicePipeBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceConnectInfoStatus_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDeviceConnectInfoStatus") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDeviceConnectInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceConnectInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceConnectInfo_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"startConnected"), aname="_startConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"allowGuestControl"), aname="_allowGuestControl", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDeviceConnectInfo_Def.__bases__: + bases = list(ns0.VirtualDeviceConnectInfo_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDeviceConnectInfo_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDevice_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"deviceInfo"), aname="_deviceInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceBackingInfo",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConnectInfo",lazy=True)(pname=(ns,"connectable"), aname="_connectable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"controllerKey"), aname="_controllerKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"unitNumber"), aname="_unitNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDevice_Def.__bases__: + bases = list(ns0.VirtualDevice_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDevice_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualDevice") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualDevice_Def.schema + TClist = [GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"VirtualDevice"), aname="_VirtualDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualDevice = [] + return + Holder.__name__ = "ArrayOfVirtualDevice_Holder" + self.pyclass = Holder + + class VirtualDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceBackingOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualDeviceBackingOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualDeviceBackingOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualDeviceBackingOption_Def.schema + TClist = [GTD("urn:vim25","VirtualDeviceBackingOption",lazy=True)(pname=(ns,"VirtualDeviceBackingOption"), aname="_VirtualDeviceBackingOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualDeviceBackingOption = [] + return + Holder.__name__ = "ArrayOfVirtualDeviceBackingOption_Holder" + self.pyclass = Holder + + class VirtualDeviceFileExtension_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDeviceFileExtension") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDeviceFileBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceFileBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceFileBackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"fileNameExtensions"), aname="_fileNameExtensions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDeviceFileBackingOption_Def.__bases__: + bases = list(ns0.VirtualDeviceFileBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingOption_Def) + ns0.VirtualDeviceFileBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceDeviceBackingOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoDetectAvailable"), aname="_autoDetectAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDeviceDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualDeviceDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingOption_Def) + ns0.VirtualDeviceDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceRemoteDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceRemoteDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceRemoteDeviceBackingOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoDetectAvailable"), aname="_autoDetectAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingOption_Def) + ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDevicePipeBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDevicePipeBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDevicePipeBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDevicePipeBackingOption_Def.__bases__: + bases = list(ns0.VirtualDevicePipeBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingOption_Def) + ns0.VirtualDevicePipeBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceConnectOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceConnectOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceConnectOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"startConnected"), aname="_startConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"allowGuestControl"), aname="_allowGuestControl", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDeviceConnectOption_Def.__bases__: + bases = list(ns0.VirtualDeviceConnectOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDeviceConnectOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDeviceOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceOption_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConnectOption",lazy=True)(pname=(ns,"connectOption"), aname="_connectOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoAssignController"), aname="_autoAssignController", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceBackingOption",lazy=True)(pname=(ns,"backingOption"), aname="_backingOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultBackingOptionIndex"), aname="_defaultBackingOptionIndex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licensingLimit"), aname="_licensingLimit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deprecated"), aname="_deprecated", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"plugAndPlay"), aname="_plugAndPlay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hotRemoveSupported"), aname="_hotRemoveSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDeviceOption_Def.__bases__: + bases = list(ns0.VirtualDeviceOption_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDeviceOption_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualDeviceOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualDeviceOption") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualDeviceOption_Def.schema + TClist = [GTD("urn:vim25","VirtualDeviceOption",lazy=True)(pname=(ns,"VirtualDeviceOption"), aname="_VirtualDeviceOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualDeviceOption = [] + return + Holder.__name__ = "ArrayOfVirtualDeviceOption_Holder" + self.pyclass = Holder + + class VirtualDeviceConfigSpecOperation_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDeviceConfigSpecOperation") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDeviceConfigSpecFileOperation_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDeviceConfigSpecFileOperation") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDeviceConfigSpec_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDeviceConfigSpec") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDeviceConfigSpec_Def.schema + TClist = [GTD("urn:vim25","VirtualDeviceConfigSpecOperation",lazy=True)(pname=(ns,"operation"), aname="_operation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConfigSpecFileOperation",lazy=True)(pname=(ns,"fileOperation"), aname="_fileOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.DynamicData_Def not in ns0.VirtualDeviceConfigSpec_Def.__bases__: + bases = list(ns0.VirtualDeviceConfigSpec_Def.__bases__) + bases.insert(0, ns0.DynamicData_Def) + ns0.VirtualDeviceConfigSpec_Def.__bases__ = tuple(bases) + + ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualDeviceConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualDeviceConfigSpec") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualDeviceConfigSpec_Def.schema + TClist = [GTD("urn:vim25","VirtualDeviceConfigSpec",lazy=True)(pname=(ns,"VirtualDeviceConfigSpec"), aname="_VirtualDeviceConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualDeviceConfigSpec = [] + return + Holder.__name__ = "ArrayOfVirtualDeviceConfigSpec_Holder" + self.pyclass = Holder + + class VirtualDiskSparseVer1BackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskSparseVer1BackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskSparseVer1BackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"spaceUsedInKB"), aname="_spaceUsedInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSparseVer1BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskSparseVer1BackingInfo_Def.__bases__: + bases = list(ns0.VirtualDiskSparseVer1BackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualDiskSparseVer1BackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskSparseVer2BackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskSparseVer2BackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskSparseVer2BackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"spaceUsedInKB"), aname="_spaceUsedInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSparseVer2BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskSparseVer2BackingInfo_Def.__bases__: + bases = list(ns0.VirtualDiskSparseVer2BackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualDiskSparseVer2BackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskFlatVer1BackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskFlatVer1BackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskFlatVer1BackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskFlatVer1BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskFlatVer1BackingInfo_Def.__bases__: + bases = list(ns0.VirtualDiskFlatVer1BackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualDiskFlatVer1BackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskFlatVer2BackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskFlatVer2BackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskFlatVer2BackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thinProvisioned"), aname="_thinProvisioned", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"eagerlyScrub"), aname="_eagerlyScrub", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskFlatVer2BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskFlatVer2BackingInfo_Def.__bases__: + bases = list(ns0.VirtualDiskFlatVer2BackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualDiskFlatVer2BackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskRawDiskVer2BackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskRawDiskVer2BackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskRawDiskVer2BackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"descriptorFileName"), aname="_descriptorFileName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__bases__: + bases = list(ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskPartitionedRawDiskVer2BackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskPartitionedRawDiskVer2BackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDiskRawDiskVer2BackingInfo_Def not in ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.__bases__: + bases = list(ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDiskRawDiskVer2BackingInfo_Def) + ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskRawDiskMappingVer1BackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskRawDiskMappingVer1BackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"lunUuid"), aname="_lunUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compatibilityMode"), aname="_compatibilityMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskRawDiskMappingVer1BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.__bases__: + bases = list(ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDisk_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDisk") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDisk_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"capacityInKB"), aname="_capacityInKB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SharesInfo",lazy=True)(pname=(ns,"shares"), aname="_shares", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualDisk_Def.__bases__: + bases = list(ns0.VirtualDisk_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualDisk_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ArrayOfVirtualDisk_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualDisk") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualDisk_Def.schema + TClist = [GTD("urn:vim25","VirtualDisk",lazy=True)(pname=(ns,"VirtualDisk"), aname="_VirtualDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualDisk = [] + return + Holder.__name__ = "ArrayOfVirtualDisk_Holder" + self.pyclass = Holder + + class VirtualDiskMode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDiskMode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDiskCompatibilityMode_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualDiskCompatibilityMode") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualDiskSparseVer1BackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskSparseVer1BackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskSparseVer1BackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskModes"), aname="_diskModes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskSparseVer1BackingOption_Def.__bases__: + bases = list(ns0.VirtualDiskSparseVer1BackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualDiskSparseVer1BackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskSparseVer2BackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskSparseVer2BackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskSparseVer2BackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hotGrowable"), aname="_hotGrowable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskSparseVer2BackingOption_Def.__bases__: + bases = list(ns0.VirtualDiskSparseVer2BackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualDiskSparseVer2BackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskFlatVer1BackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskFlatVer1BackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskFlatVer1BackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskFlatVer1BackingOption_Def.__bases__: + bases = list(ns0.VirtualDiskFlatVer1BackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualDiskFlatVer1BackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskFlatVer2BackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskFlatVer2BackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskFlatVer2BackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hotGrowable"), aname="_hotGrowable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"thinProvisioned"), aname="_thinProvisioned", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"eagerlyScrub"), aname="_eagerlyScrub", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskFlatVer2BackingOption_Def.__bases__: + bases = list(ns0.VirtualDiskFlatVer2BackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualDiskFlatVer2BackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskRawDiskVer2BackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskRawDiskVer2BackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskRawDiskVer2BackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"descriptorFileNameExtensions"), aname="_descriptorFileNameExtensions", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualDiskRawDiskVer2BackingOption_Def.__bases__: + bases = list(ns0.VirtualDiskRawDiskVer2BackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualDiskRawDiskVer2BackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskPartitionedRawDiskVer2BackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskPartitionedRawDiskVer2BackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDiskRawDiskVer2BackingOption_Def not in ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.__bases__: + bases = list(ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDiskRawDiskVer2BackingOption_Def) + ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDiskRawDiskVer2BackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskRawDiskMappingVer1BackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskRawDiskMappingVer1BackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"descriptorFileNameExtensions"), aname="_descriptorFileNameExtensions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"compatibilityMode"), aname="_compatibilityMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.__bases__: + bases = list(ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualDiskOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualDiskOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualDiskOption_Def.schema + TClist = [GTD("urn:vim25","LongOption",lazy=True)(pname=(ns,"capacityInKB"), aname="_capacityInKB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualDiskOption_Def.__bases__: + bases = list(ns0.VirtualDiskOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualDiskOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualE1000_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualE1000") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualE1000_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualEthernetCard_Def not in ns0.VirtualE1000_Def.__bases__: + bases = list(ns0.VirtualE1000_Def.__bases__) + bases.insert(0, ns0.VirtualEthernetCard_Def) + ns0.VirtualE1000_Def.__bases__ = tuple(bases) + + ns0.VirtualEthernetCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualE1000Option_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualE1000Option") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualE1000Option_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualEthernetCardOption_Def not in ns0.VirtualE1000Option_Def.__bases__: + bases = list(ns0.VirtualE1000Option_Def.__bases__) + bases.insert(0, ns0.VirtualEthernetCardOption_Def) + ns0.VirtualE1000Option_Def.__bases__ = tuple(bases) + + ns0.VirtualEthernetCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEnsoniq1371_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEnsoniq1371") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEnsoniq1371_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSoundCard_Def not in ns0.VirtualEnsoniq1371_Def.__bases__: + bases = list(ns0.VirtualEnsoniq1371_Def.__bases__) + bases.insert(0, ns0.VirtualSoundCard_Def) + ns0.VirtualEnsoniq1371_Def.__bases__ = tuple(bases) + + ns0.VirtualSoundCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEnsoniq1371Option_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEnsoniq1371Option") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEnsoniq1371Option_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSoundCardOption_Def not in ns0.VirtualEnsoniq1371Option_Def.__bases__: + bases = list(ns0.VirtualEnsoniq1371Option_Def.__bases__) + bases.insert(0, ns0.VirtualSoundCardOption_Def) + ns0.VirtualEnsoniq1371Option_Def.__bases__ = tuple(bases) + + ns0.VirtualSoundCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardNetworkBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardNetworkBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardNetworkBackingInfo_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inPassthroughMode"), aname="_inPassthroughMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualEthernetCardNetworkBackingInfo_Def.__bases__: + bases = list(ns0.VirtualEthernetCardNetworkBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualEthernetCardNetworkBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardLegacyNetworkBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardLegacyNetworkBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.__bases__: + bases = list(ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardDistributedVirtualPortBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardDistributedVirtualPortBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.__bases__: + bases = list(ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) + ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCard_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCard") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCard_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"addressType"), aname="_addressType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"wakeOnLanEnabled"), aname="_wakeOnLanEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualEthernetCard_Def.__bases__: + bases = list(ns0.VirtualEthernetCard_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualEthernetCard_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardNetworkBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardNetworkBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardNetworkBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualEthernetCardNetworkBackingOption_Def.__bases__: + bases = list(ns0.VirtualEthernetCardNetworkBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualEthernetCardNetworkBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardLegacyNetworkDeviceName_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardLegacyNetworkDeviceName") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualEthernetCardLegacyNetworkBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardLegacyNetworkBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.__bases__: + bases = list(ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardDVPortBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardDVPortBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardDVPortBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualEthernetCardDVPortBackingOption_Def.__bases__: + bases = list(ns0.VirtualEthernetCardDVPortBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceBackingOption_Def) + ns0.VirtualEthernetCardDVPortBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualEthernetCardMacType_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardMacType") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualEthernetCardOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualEthernetCardOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualEthernetCardOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"supportedOUI"), aname="_supportedOUI", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"macType"), aname="_macType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"wakeOnLanEnabled"), aname="_wakeOnLanEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualEthernetCardOption_Def.__bases__: + bases = list(ns0.VirtualEthernetCardOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualEthernetCardOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppyImageBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppyImageBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppyImageBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualFloppyImageBackingInfo_Def.__bases__: + bases = list(ns0.VirtualFloppyImageBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualFloppyImageBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppyDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppyDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppyDeviceBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualFloppyDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualFloppyDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualFloppyDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppyRemoteDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppyRemoteDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceRemoteDeviceBackingInfo_Def not in ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingInfo_Def) + ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppy_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppy") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppy_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualFloppy_Def.__bases__: + bases = list(ns0.VirtualFloppy_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualFloppy_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppyImageBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppyImageBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppyImageBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualFloppyImageBackingOption_Def.__bases__: + bases = list(ns0.VirtualFloppyImageBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualFloppyImageBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppyDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppyDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppyDeviceBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualFloppyDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualFloppyDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualFloppyDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppyRemoteDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppyRemoteDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppyRemoteDeviceBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceRemoteDeviceBackingOption_Def not in ns0.VirtualFloppyRemoteDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualFloppyRemoteDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingOption_Def) + ns0.VirtualFloppyRemoteDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualFloppyOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualFloppyOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualFloppyOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualFloppyOption_Def.__bases__: + bases = list(ns0.VirtualFloppyOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualFloppyOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualIDEController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualIDEController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualIDEController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualController_Def not in ns0.VirtualIDEController_Def.__bases__: + bases = list(ns0.VirtualIDEController_Def.__bases__) + bases.insert(0, ns0.VirtualController_Def) + ns0.VirtualIDEController_Def.__bases__ = tuple(bases) + + ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualIDEControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualIDEControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualIDEControllerOption_Def.schema + TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numIDEDisks"), aname="_numIDEDisks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numIDECdroms"), aname="_numIDECdroms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualControllerOption_Def not in ns0.VirtualIDEControllerOption_Def.__bases__: + bases = list(ns0.VirtualIDEControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualControllerOption_Def) + ns0.VirtualIDEControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualKeyboard_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualKeyboard") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualKeyboard_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualKeyboard_Def.__bases__: + bases = list(ns0.VirtualKeyboard_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualKeyboard_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualKeyboardOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualKeyboardOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualKeyboardOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualKeyboardOption_Def.__bases__: + bases = list(ns0.VirtualKeyboardOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualKeyboardOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualLsiLogicController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualLsiLogicController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualLsiLogicController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIController_Def not in ns0.VirtualLsiLogicController_Def.__bases__: + bases = list(ns0.VirtualLsiLogicController_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIController_Def) + ns0.VirtualLsiLogicController_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualLsiLogicControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualLsiLogicControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualLsiLogicControllerOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIControllerOption_Def not in ns0.VirtualLsiLogicControllerOption_Def.__bases__: + bases = list(ns0.VirtualLsiLogicControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIControllerOption_Def) + ns0.VirtualLsiLogicControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualLsiLogicSASController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualLsiLogicSASController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualLsiLogicSASController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIController_Def not in ns0.VirtualLsiLogicSASController_Def.__bases__: + bases = list(ns0.VirtualLsiLogicSASController_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIController_Def) + ns0.VirtualLsiLogicSASController_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualLsiLogicSASControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualLsiLogicSASControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualLsiLogicSASControllerOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSCSIControllerOption_Def not in ns0.VirtualLsiLogicSASControllerOption_Def.__bases__: + bases = list(ns0.VirtualLsiLogicSASControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualSCSIControllerOption_Def) + ns0.VirtualLsiLogicSASControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCIController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCIController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCIController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualController_Def not in ns0.VirtualPCIController_Def.__bases__: + bases = list(ns0.VirtualPCIController_Def.__bases__) + bases.insert(0, ns0.VirtualController_Def) + ns0.VirtualPCIController_Def.__bases__ = tuple(bases) + + ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCIControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCIControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCIControllerOption_Def.schema + TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSIControllers"), aname="_numSCSIControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numEthernetCards"), aname="_numEthernetCards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVideoCards"), aname="_numVideoCards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSoundCards"), aname="_numSoundCards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVmiRoms"), aname="_numVmiRoms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVmciDevices"), aname="_numVmciDevices", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPCIPassthroughDevices"), aname="_numPCIPassthroughDevices", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSasSCSIControllers"), aname="_numSasSCSIControllers", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVmxnet3EthernetCards"), aname="_numVmxnet3EthernetCards", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numParaVirtualSCSIControllers"), aname="_numParaVirtualSCSIControllers", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualControllerOption_Def not in ns0.VirtualPCIControllerOption_Def.__bases__: + bases = list(ns0.VirtualPCIControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualControllerOption_Def) + ns0.VirtualPCIControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCIPassthroughDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCIPassthroughDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemId"), aname="_systemId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"vendorId"), aname="_vendorId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCIPassthrough_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCIPassthrough") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCIPassthrough_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualPCIPassthrough_Def.__bases__: + bases = list(ns0.VirtualPCIPassthrough_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualPCIPassthrough_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCIPassthroughDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCIPassthroughDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCIPassthroughDeviceBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualPCIPassthroughDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualPCIPassthroughDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualPCIPassthroughDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCIPassthroughOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCIPassthroughOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCIPassthroughOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualPCIPassthroughOption_Def.__bases__: + bases = list(ns0.VirtualPCIPassthroughOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualPCIPassthroughOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCNet32_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCNet32") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCNet32_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualEthernetCard_Def not in ns0.VirtualPCNet32_Def.__bases__: + bases = list(ns0.VirtualPCNet32_Def.__bases__) + bases.insert(0, ns0.VirtualEthernetCard_Def) + ns0.VirtualPCNet32_Def.__bases__ = tuple(bases) + + ns0.VirtualEthernetCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPCNet32Option_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPCNet32Option") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPCNet32Option_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"supportsMorphing"), aname="_supportsMorphing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualEthernetCardOption_Def not in ns0.VirtualPCNet32Option_Def.__bases__: + bases = list(ns0.VirtualPCNet32Option_Def.__bases__) + bases.insert(0, ns0.VirtualEthernetCardOption_Def) + ns0.VirtualPCNet32Option_Def.__bases__ = tuple(bases) + + ns0.VirtualEthernetCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPS2Controller_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPS2Controller") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPS2Controller_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualController_Def not in ns0.VirtualPS2Controller_Def.__bases__: + bases = list(ns0.VirtualPS2Controller_Def.__bases__) + bases.insert(0, ns0.VirtualController_Def) + ns0.VirtualPS2Controller_Def.__bases__ = tuple(bases) + + ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPS2ControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPS2ControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPS2ControllerOption_Def.schema + TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numKeyboards"), aname="_numKeyboards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPointingDevices"), aname="_numPointingDevices", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualControllerOption_Def not in ns0.VirtualPS2ControllerOption_Def.__bases__: + bases = list(ns0.VirtualPS2ControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualControllerOption_Def) + ns0.VirtualPS2ControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualParallelPortFileBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualParallelPortFileBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualParallelPortFileBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualParallelPortFileBackingInfo_Def.__bases__: + bases = list(ns0.VirtualParallelPortFileBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualParallelPortFileBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualParallelPortDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualParallelPortDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualParallelPortDeviceBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualParallelPortDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualParallelPortDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualParallelPortDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualParallelPort_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualParallelPort") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualParallelPort_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualParallelPort_Def.__bases__: + bases = list(ns0.VirtualParallelPort_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualParallelPort_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualParallelPortFileBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualParallelPortFileBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualParallelPortFileBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualParallelPortFileBackingOption_Def.__bases__: + bases = list(ns0.VirtualParallelPortFileBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualParallelPortFileBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualParallelPortDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualParallelPortDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualParallelPortDeviceBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualParallelPortDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualParallelPortDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualParallelPortDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualParallelPortOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualParallelPortOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualParallelPortOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualParallelPortOption_Def.__bases__: + bases = list(ns0.VirtualParallelPortOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualParallelPortOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPointingDeviceDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPointingDeviceDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPointingDeviceDeviceBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"hostPointingDevice"), aname="_hostPointingDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualPointingDeviceDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualPointingDeviceDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualPointingDeviceDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPointingDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPointingDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPointingDevice_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualPointingDevice_Def.__bases__: + bases = list(ns0.VirtualPointingDevice_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualPointingDevice_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPointingDeviceHostChoice_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualPointingDeviceHostChoice") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualPointingDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPointingDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPointingDeviceBackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"hostPointingDevice"), aname="_hostPointingDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualPointingDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualPointingDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualPointingDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualPointingDeviceOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualPointingDeviceOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualPointingDeviceOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualPointingDeviceOption_Def.__bases__: + bases = list(ns0.VirtualPointingDeviceOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualPointingDeviceOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSCSISharing_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualSCSISharing") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class ArrayOfVirtualSCSISharing_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfVirtualSCSISharing") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfVirtualSCSISharing_Def.schema + TClist = [GTD("urn:vim25","VirtualSCSISharing",lazy=True)(pname=(ns,"VirtualSCSISharing"), aname="_VirtualSCSISharing", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._VirtualSCSISharing = [] + return + Holder.__name__ = "ArrayOfVirtualSCSISharing_Holder" + self.pyclass = Holder + + class VirtualSCSIController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSCSIController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSCSIController_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"hotAddRemove"), aname="_hotAddRemove", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualSCSISharing",lazy=True)(pname=(ns,"sharedBus"), aname="_sharedBus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"scsiCtlrUnitNumber"), aname="_scsiCtlrUnitNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualController_Def not in ns0.VirtualSCSIController_Def.__bases__: + bases = list(ns0.VirtualSCSIController_Def.__bases__) + bases.insert(0, ns0.VirtualController_Def) + ns0.VirtualSCSIController_Def.__bases__ = tuple(bases) + + ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSCSIControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSCSIControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSCSIControllerOption_Def.schema + TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSIDisks"), aname="_numSCSIDisks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSICdroms"), aname="_numSCSICdroms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSIPassthrough"), aname="_numSCSIPassthrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualSCSISharing",lazy=True)(pname=(ns,"sharing"), aname="_sharing", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultSharedIndex"), aname="_defaultSharedIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"hotAddRemove"), aname="_hotAddRemove", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"scsiCtlrUnitNumber"), aname="_scsiCtlrUnitNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualControllerOption_Def not in ns0.VirtualSCSIControllerOption_Def.__bases__: + bases = list(ns0.VirtualSCSIControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualControllerOption_Def) + ns0.VirtualSCSIControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSCSIPassthroughDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSCSIPassthroughDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSCSIPassthrough_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSCSIPassthrough") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSCSIPassthrough_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualSCSIPassthrough_Def.__bases__: + bases = list(ns0.VirtualSCSIPassthrough_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualSCSIPassthrough_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSCSIPassthroughDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSCSIPassthroughDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSCSIPassthroughOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSCSIPassthroughOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSCSIPassthroughOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualSCSIPassthroughOption_Def.__bases__: + bases = list(ns0.VirtualSCSIPassthroughOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualSCSIPassthroughOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSIOController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSIOController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSIOController_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualController_Def not in ns0.VirtualSIOController_Def.__bases__: + bases = list(ns0.VirtualSIOController_Def.__bases__) + bases.insert(0, ns0.VirtualController_Def) + ns0.VirtualSIOController_Def.__bases__ = tuple(bases) + + ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSIOControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSIOControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSIOControllerOption_Def.schema + TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numFloppyDrives"), aname="_numFloppyDrives", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSerialPorts"), aname="_numSerialPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numParallelPorts"), aname="_numParallelPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualControllerOption_Def not in ns0.VirtualSIOControllerOption_Def.__bases__: + bases = list(ns0.VirtualSIOControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualControllerOption_Def) + ns0.VirtualSIOControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPortFileBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPortFileBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPortFileBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualSerialPortFileBackingInfo_Def.__bases__: + bases = list(ns0.VirtualSerialPortFileBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) + ns0.VirtualSerialPortFileBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPortDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPortDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPortDeviceBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualSerialPortDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualSerialPortDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualSerialPortDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPortPipeBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPortPipeBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPortPipeBackingInfo_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"endpoint"), aname="_endpoint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"noRxLoss"), aname="_noRxLoss", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevicePipeBackingInfo_Def not in ns0.VirtualSerialPortPipeBackingInfo_Def.__bases__: + bases = list(ns0.VirtualSerialPortPipeBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDevicePipeBackingInfo_Def) + ns0.VirtualSerialPortPipeBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDevicePipeBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPort_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPort") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPort_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"yieldOnPoll"), aname="_yieldOnPoll", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualSerialPort_Def.__bases__: + bases = list(ns0.VirtualSerialPort_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualSerialPort_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPortEndPoint_Def(ZSI.TC.String, TypeDefinition): + schema = "urn:vim25" + type = (schema, "VirtualSerialPortEndPoint") + def __init__(self, pname, **kw): + ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) + class Holder(str): + typecode = self + self.pyclass = Holder + + class VirtualSerialPortFileBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPortFileBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPortFileBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualSerialPortFileBackingOption_Def.__bases__: + bases = list(ns0.VirtualSerialPortFileBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) + ns0.VirtualSerialPortFileBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPortDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPortDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPortDeviceBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualSerialPortDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualSerialPortDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualSerialPortDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPortPipeBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPortPipeBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPortPipeBackingOption_Def.schema + TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"endpoint"), aname="_endpoint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"noRxLoss"), aname="_noRxLoss", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevicePipeBackingOption_Def not in ns0.VirtualSerialPortPipeBackingOption_Def.__bases__: + bases = list(ns0.VirtualSerialPortPipeBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDevicePipeBackingOption_Def) + ns0.VirtualSerialPortPipeBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDevicePipeBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSerialPortOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSerialPortOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSerialPortOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"yieldOnPoll"), aname="_yieldOnPoll", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualSerialPortOption_Def.__bases__: + bases = list(ns0.VirtualSerialPortOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualSerialPortOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSoundBlaster16_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSoundBlaster16") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSoundBlaster16_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSoundCard_Def not in ns0.VirtualSoundBlaster16_Def.__bases__: + bases = list(ns0.VirtualSoundBlaster16_Def.__bases__) + bases.insert(0, ns0.VirtualSoundCard_Def) + ns0.VirtualSoundBlaster16_Def.__bases__ = tuple(bases) + + ns0.VirtualSoundCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSoundBlaster16Option_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSoundBlaster16Option") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSoundBlaster16Option_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualSoundCardOption_Def not in ns0.VirtualSoundBlaster16Option_Def.__bases__: + bases = list(ns0.VirtualSoundBlaster16Option_Def.__bases__) + bases.insert(0, ns0.VirtualSoundCardOption_Def) + ns0.VirtualSoundBlaster16Option_Def.__bases__ = tuple(bases) + + ns0.VirtualSoundCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSoundCardDeviceBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSoundCardDeviceBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSoundCardDeviceBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualSoundCardDeviceBackingInfo_Def.__bases__: + bases = list(ns0.VirtualSoundCardDeviceBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualSoundCardDeviceBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSoundCard_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSoundCard") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSoundCard_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualSoundCard_Def.__bases__: + bases = list(ns0.VirtualSoundCard_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualSoundCard_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSoundCardDeviceBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSoundCardDeviceBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSoundCardDeviceBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualSoundCardDeviceBackingOption_Def.__bases__: + bases = list(ns0.VirtualSoundCardDeviceBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualSoundCardDeviceBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualSoundCardOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualSoundCardOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualSoundCardOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualSoundCardOption_Def.__bases__: + bases = list(ns0.VirtualSoundCardOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualSoundCardOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualUSBUSBBackingInfo_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualUSBUSBBackingInfo") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualUSBUSBBackingInfo_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualUSBUSBBackingInfo_Def.__bases__: + bases = list(ns0.VirtualUSBUSBBackingInfo_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) + ns0.VirtualUSBUSBBackingInfo_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualUSB_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualUSB") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualUSB_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualUSB_Def.__bases__: + bases = list(ns0.VirtualUSB_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualUSB_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualUSBController_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualUSBController") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualUSBController_Def.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"autoConnectDevices"), aname="_autoConnectDevices", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ehciEnabled"), aname="_ehciEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualController_Def not in ns0.VirtualUSBController_Def.__bases__: + bases = list(ns0.VirtualUSBController_Def.__bases__) + bases.insert(0, ns0.VirtualController_Def) + ns0.VirtualUSBController_Def.__bases__ = tuple(bases) + + ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualUSBControllerOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualUSBControllerOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualUSBControllerOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoConnectDevices"), aname="_autoConnectDevices", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"ehciSupported"), aname="_ehciSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualControllerOption_Def not in ns0.VirtualUSBControllerOption_Def.__bases__: + bases = list(ns0.VirtualUSBControllerOption_Def.__bases__) + bases.insert(0, ns0.VirtualControllerOption_Def) + ns0.VirtualUSBControllerOption_Def.__bases__ = tuple(bases) + + ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualUSBUSBBackingOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualUSBUSBBackingOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualUSBUSBBackingOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualUSBUSBBackingOption_Def.__bases__: + bases = list(ns0.VirtualUSBUSBBackingOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) + ns0.VirtualUSBUSBBackingOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualUSBOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualUSBOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualUSBOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualUSBOption_Def.__bases__: + bases = list(ns0.VirtualUSBOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualUSBOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineVMCIDevice_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineVMCIDevice") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineVMCIDevice_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"allowUnrestrictedCommunication"), aname="_allowUnrestrictedCommunication", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualMachineVMCIDevice_Def.__bases__: + bases = list(ns0.VirtualMachineVMCIDevice_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualMachineVMCIDevice_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineVMCIDeviceOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineVMCIDeviceOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineVMCIDeviceOption_Def.schema + TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"allowUnrestrictedCommunication"), aname="_allowUnrestrictedCommunication", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualMachineVMCIDeviceOption_Def.__bases__: + bases = list(ns0.VirtualMachineVMCIDeviceOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualMachineVMCIDeviceOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineVMIROM_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineVMIROM") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineVMIROM_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualMachineVMIROM_Def.__bases__: + bases = list(ns0.VirtualMachineVMIROM_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualMachineVMIROM_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVMIROMOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVMIROMOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVMIROMOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualVMIROMOption_Def.__bases__: + bases = list(ns0.VirtualVMIROMOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualVMIROMOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualMachineVideoCard_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualMachineVideoCard") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualMachineVideoCard_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"videoRamSizeInKB"), aname="_videoRamSizeInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numDisplays"), aname="_numDisplays", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enable3DSupport"), aname="_enable3DSupport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDevice_Def not in ns0.VirtualMachineVideoCard_Def.__bases__: + bases = list(ns0.VirtualMachineVideoCard_Def.__bases__) + bases.insert(0, ns0.VirtualDevice_Def) + ns0.VirtualMachineVideoCard_Def.__bases__ = tuple(bases) + + ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVideoCardOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVideoCardOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVideoCardOption_Def.schema + TClist = [GTD("urn:vim25","LongOption",lazy=True)(pname=(ns,"videoRamSizeInKB"), aname="_videoRamSizeInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numDisplays"), aname="_numDisplays", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"support3D"), aname="_support3D", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualDeviceOption_Def not in ns0.VirtualVideoCardOption_Def.__bases__: + bases = list(ns0.VirtualVideoCardOption_Def.__bases__) + bases.insert(0, ns0.VirtualDeviceOption_Def) + ns0.VirtualVideoCardOption_Def.__bases__ = tuple(bases) + + ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVmxnet_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVmxnet") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVmxnet_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualEthernetCard_Def not in ns0.VirtualVmxnet_Def.__bases__: + bases = list(ns0.VirtualVmxnet_Def.__bases__) + bases.insert(0, ns0.VirtualEthernetCard_Def) + ns0.VirtualVmxnet_Def.__bases__ = tuple(bases) + + ns0.VirtualEthernetCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVmxnet2_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVmxnet2") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVmxnet2_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualVmxnet_Def not in ns0.VirtualVmxnet2_Def.__bases__: + bases = list(ns0.VirtualVmxnet2_Def.__bases__) + bases.insert(0, ns0.VirtualVmxnet_Def) + ns0.VirtualVmxnet2_Def.__bases__ = tuple(bases) + + ns0.VirtualVmxnet_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVmxnet2Option_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVmxnet2Option") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVmxnet2Option_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualVmxnetOption_Def not in ns0.VirtualVmxnet2Option_Def.__bases__: + bases = list(ns0.VirtualVmxnet2Option_Def.__bases__) + bases.insert(0, ns0.VirtualVmxnetOption_Def) + ns0.VirtualVmxnet2Option_Def.__bases__ = tuple(bases) + + ns0.VirtualVmxnetOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVmxnet3_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVmxnet3") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVmxnet3_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualVmxnet_Def not in ns0.VirtualVmxnet3_Def.__bases__: + bases = list(ns0.VirtualVmxnet3_Def.__bases__) + bases.insert(0, ns0.VirtualVmxnet_Def) + ns0.VirtualVmxnet3_Def.__bases__ = tuple(bases) + + ns0.VirtualVmxnet_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVmxnet3Option_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVmxnet3Option") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVmxnet3Option_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualVmxnetOption_Def not in ns0.VirtualVmxnet3Option_Def.__bases__: + bases = list(ns0.VirtualVmxnet3Option_Def.__bases__) + bases.insert(0, ns0.VirtualVmxnetOption_Def) + ns0.VirtualVmxnet3Option_Def.__bases__ = tuple(bases) + + ns0.VirtualVmxnetOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class VirtualVmxnetOption_Def(TypeDefinition): + #complexType/complexContent extension + schema = "urn:vim25" + type = (schema, "VirtualVmxnetOption") + def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): + ns = ns0.VirtualVmxnetOption_Def.schema + TClist = [] + attributes = self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + if ns0.VirtualEthernetCardOption_Def not in ns0.VirtualVmxnetOption_Def.__bases__: + bases = list(ns0.VirtualVmxnetOption_Def.__bases__) + bases.insert(0, ns0.VirtualEthernetCardOption_Def) + ns0.VirtualVmxnetOption_Def.__bases__ = tuple(bases) + + ns0.VirtualEthernetCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) + + class ManagedObjectReference_Def(ZSI.TC.String, TypeDefinition): + # ComplexType/SimpleContent derivation of built-in type + schema = "urn:vim25" + type = (schema, "ManagedObjectReference") + def __init__(self, pname, **kw): + if getattr(self, "attribute_typecode_dict", None) is None: self.attribute_typecode_dict = {} + # attribute handling code + self.attribute_typecode_dict["type"] = ZSI.TC.String() + ZSI.TC.String.__init__(self, pname, **kw) + class Holder(str): + __metaclass__ = pyclass_type + typecode = self + self.pyclass = Holder + + class ArrayOfString_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfString") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfString_Def.schema + TClist = [ZSI.TC.String(pname=(ns,"string"), aname="_string", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._string = [] + return + Holder.__name__ = "ArrayOfString_Holder" + self.pyclass = Holder + + class ArrayOfAnyType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfAnyType") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfAnyType_Def.schema + TClist = [ZSI.TC.AnyType(pname=(ns,"anyType"), aname="_anyType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._anyType = [] + return + Holder.__name__ = "ArrayOfAnyType_Holder" + self.pyclass = Holder + + class ArrayOfManagedObjectReference_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfManagedObjectReference") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfManagedObjectReference_Def.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"ManagedObjectReference"), aname="_ManagedObjectReference", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._ManagedObjectReference = [] + return + Holder.__name__ = "ArrayOfManagedObjectReference_Holder" + self.pyclass = Holder + + class ArrayOfByte_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfByte") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfByte_Def.schema + TClist = [ZSI.TCnumbers.Ibyte(pname=(ns,"byte"), aname="_byte", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._byte = [] + return + Holder.__name__ = "ArrayOfByte_Holder" + self.pyclass = Holder + + class ArrayOfInt_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfInt") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfInt_Def.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"int"), aname="_int", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._int = [] + return + Holder.__name__ = "ArrayOfInt_Holder" + self.pyclass = Holder + + class ArrayOfLong_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfLong") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfLong_Def.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"long"), aname="_long", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._long = [] + return + Holder.__name__ = "ArrayOfLong_Holder" + self.pyclass = Holder + + class ArrayOfShort_Def(ZSI.TCcompound.ComplexType, TypeDefinition): + schema = "urn:vim25" + type = (schema, "ArrayOfShort") + def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): + ns = ns0.ArrayOfShort_Def.schema + TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"short"), aname="_short", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + self.attribute_typecode_dict = attributes or {} + if extend: TClist += ofwhat + if restrict: TClist = ofwhat + ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._short = [] + return + Holder.__name__ = "ArrayOfShort_Holder" + self.pyclass = Holder + + class HostCommunicationFault_Dec(ElementDeclaration): + literal = "HostCommunicationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostCommunicationFault") + kw["aname"] = "_HostCommunicationFault" + if ns0.HostCommunication_Def not in ns0.HostCommunicationFault_Dec.__bases__: + bases = list(ns0.HostCommunicationFault_Dec.__bases__) + bases.insert(0, ns0.HostCommunication_Def) + ns0.HostCommunicationFault_Dec.__bases__ = tuple(bases) + + ns0.HostCommunication_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostCommunicationFault_Dec_Holder" + + class HostNotConnectedFault_Dec(ElementDeclaration): + literal = "HostNotConnectedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostNotConnectedFault") + kw["aname"] = "_HostNotConnectedFault" + if ns0.HostNotConnected_Def not in ns0.HostNotConnectedFault_Dec.__bases__: + bases = list(ns0.HostNotConnectedFault_Dec.__bases__) + bases.insert(0, ns0.HostNotConnected_Def) + ns0.HostNotConnectedFault_Dec.__bases__ = tuple(bases) + + ns0.HostNotConnected_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostNotConnectedFault_Dec_Holder" + + class HostNotReachableFault_Dec(ElementDeclaration): + literal = "HostNotReachableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostNotReachableFault") + kw["aname"] = "_HostNotReachableFault" + if ns0.HostNotReachable_Def not in ns0.HostNotReachableFault_Dec.__bases__: + bases = list(ns0.HostNotReachableFault_Dec.__bases__) + bases.insert(0, ns0.HostNotReachable_Def) + ns0.HostNotReachableFault_Dec.__bases__ = tuple(bases) + + ns0.HostNotReachable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostNotReachableFault_Dec_Holder" + + class InvalidArgumentFault_Dec(ElementDeclaration): + literal = "InvalidArgumentFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidArgumentFault") + kw["aname"] = "_InvalidArgumentFault" + if ns0.InvalidArgument_Def not in ns0.InvalidArgumentFault_Dec.__bases__: + bases = list(ns0.InvalidArgumentFault_Dec.__bases__) + bases.insert(0, ns0.InvalidArgument_Def) + ns0.InvalidArgumentFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidArgument_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidArgumentFault_Dec_Holder" + + class InvalidRequestFault_Dec(ElementDeclaration): + literal = "InvalidRequestFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidRequestFault") + kw["aname"] = "_InvalidRequestFault" + if ns0.InvalidRequest_Def not in ns0.InvalidRequestFault_Dec.__bases__: + bases = list(ns0.InvalidRequestFault_Dec.__bases__) + bases.insert(0, ns0.InvalidRequest_Def) + ns0.InvalidRequestFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidRequest_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidRequestFault_Dec_Holder" + + class InvalidTypeFault_Dec(ElementDeclaration): + literal = "InvalidTypeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidTypeFault") + kw["aname"] = "_InvalidTypeFault" + if ns0.InvalidType_Def not in ns0.InvalidTypeFault_Dec.__bases__: + bases = list(ns0.InvalidTypeFault_Dec.__bases__) + bases.insert(0, ns0.InvalidType_Def) + ns0.InvalidTypeFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidTypeFault_Dec_Holder" + + class ManagedObjectNotFoundFault_Dec(ElementDeclaration): + literal = "ManagedObjectNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ManagedObjectNotFoundFault") + kw["aname"] = "_ManagedObjectNotFoundFault" + if ns0.ManagedObjectNotFound_Def not in ns0.ManagedObjectNotFoundFault_Dec.__bases__: + bases = list(ns0.ManagedObjectNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.ManagedObjectNotFound_Def) + ns0.ManagedObjectNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.ManagedObjectNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ManagedObjectNotFoundFault_Dec_Holder" + + class MethodNotFoundFault_Dec(ElementDeclaration): + literal = "MethodNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MethodNotFoundFault") + kw["aname"] = "_MethodNotFoundFault" + if ns0.MethodNotFound_Def not in ns0.MethodNotFoundFault_Dec.__bases__: + bases = list(ns0.MethodNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.MethodNotFound_Def) + ns0.MethodNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.MethodNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MethodNotFoundFault_Dec_Holder" + + class NotEnoughLicensesFault_Dec(ElementDeclaration): + literal = "NotEnoughLicensesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotEnoughLicensesFault") + kw["aname"] = "_NotEnoughLicensesFault" + if ns0.NotEnoughLicenses_Def not in ns0.NotEnoughLicensesFault_Dec.__bases__: + bases = list(ns0.NotEnoughLicensesFault_Dec.__bases__) + bases.insert(0, ns0.NotEnoughLicenses_Def) + ns0.NotEnoughLicensesFault_Dec.__bases__ = tuple(bases) + + ns0.NotEnoughLicenses_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotEnoughLicensesFault_Dec_Holder" + + class NotImplementedFault_Dec(ElementDeclaration): + literal = "NotImplementedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotImplementedFault") + kw["aname"] = "_NotImplementedFault" + if ns0.NotImplemented_Def not in ns0.NotImplementedFault_Dec.__bases__: + bases = list(ns0.NotImplementedFault_Dec.__bases__) + bases.insert(0, ns0.NotImplemented_Def) + ns0.NotImplementedFault_Dec.__bases__ = tuple(bases) + + ns0.NotImplemented_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotImplementedFault_Dec_Holder" + + class NotSupportedFault_Dec(ElementDeclaration): + literal = "NotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotSupportedFault") + kw["aname"] = "_NotSupportedFault" + if ns0.NotSupported_Def not in ns0.NotSupportedFault_Dec.__bases__: + bases = list(ns0.NotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.NotSupported_Def) + ns0.NotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.NotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotSupportedFault_Dec_Holder" + + class RequestCanceledFault_Dec(ElementDeclaration): + literal = "RequestCanceledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RequestCanceledFault") + kw["aname"] = "_RequestCanceledFault" + if ns0.RequestCanceled_Def not in ns0.RequestCanceledFault_Dec.__bases__: + bases = list(ns0.RequestCanceledFault_Dec.__bases__) + bases.insert(0, ns0.RequestCanceled_Def) + ns0.RequestCanceledFault_Dec.__bases__ = tuple(bases) + + ns0.RequestCanceled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RequestCanceledFault_Dec_Holder" + + class SecurityErrorFault_Dec(ElementDeclaration): + literal = "SecurityErrorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SecurityErrorFault") + kw["aname"] = "_SecurityErrorFault" + if ns0.SecurityError_Def not in ns0.SecurityErrorFault_Dec.__bases__: + bases = list(ns0.SecurityErrorFault_Dec.__bases__) + bases.insert(0, ns0.SecurityError_Def) + ns0.SecurityErrorFault_Dec.__bases__ = tuple(bases) + + ns0.SecurityError_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SecurityErrorFault_Dec_Holder" + + class SystemErrorFault_Dec(ElementDeclaration): + literal = "SystemErrorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SystemErrorFault") + kw["aname"] = "_SystemErrorFault" + if ns0.SystemError_Def not in ns0.SystemErrorFault_Dec.__bases__: + bases = list(ns0.SystemErrorFault_Dec.__bases__) + bases.insert(0, ns0.SystemError_Def) + ns0.SystemErrorFault_Dec.__bases__ = tuple(bases) + + ns0.SystemError_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SystemErrorFault_Dec_Holder" + + class UnexpectedFaultFault_Dec(ElementDeclaration): + literal = "UnexpectedFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnexpectedFaultFault") + kw["aname"] = "_UnexpectedFaultFault" + if ns0.UnexpectedFault_Def not in ns0.UnexpectedFaultFault_Dec.__bases__: + bases = list(ns0.UnexpectedFaultFault_Dec.__bases__) + bases.insert(0, ns0.UnexpectedFault_Def) + ns0.UnexpectedFaultFault_Dec.__bases__ = tuple(bases) + + ns0.UnexpectedFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnexpectedFaultFault_Dec_Holder" + + class InvalidCollectorVersionFault_Dec(ElementDeclaration): + literal = "InvalidCollectorVersionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidCollectorVersionFault") + kw["aname"] = "_InvalidCollectorVersionFault" + if ns0.InvalidCollectorVersion_Def not in ns0.InvalidCollectorVersionFault_Dec.__bases__: + bases = list(ns0.InvalidCollectorVersionFault_Dec.__bases__) + bases.insert(0, ns0.InvalidCollectorVersion_Def) + ns0.InvalidCollectorVersionFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidCollectorVersion_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidCollectorVersionFault_Dec_Holder" + + class InvalidPropertyFault_Dec(ElementDeclaration): + literal = "InvalidPropertyFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidPropertyFault") + kw["aname"] = "_InvalidPropertyFault" + if ns0.InvalidProperty_Def not in ns0.InvalidPropertyFault_Dec.__bases__: + bases = list(ns0.InvalidPropertyFault_Dec.__bases__) + bases.insert(0, ns0.InvalidProperty_Def) + ns0.InvalidPropertyFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidProperty_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidPropertyFault_Dec_Holder" + + class DestroyPropertyFilter_Dec(ElementDeclaration): + literal = "DestroyPropertyFilter" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestroyPropertyFilter") + kw["aname"] = "_DestroyPropertyFilter" + if ns0.DestroyPropertyFilterRequestType_Def not in ns0.DestroyPropertyFilter_Dec.__bases__: + bases = list(ns0.DestroyPropertyFilter_Dec.__bases__) + bases.insert(0, ns0.DestroyPropertyFilterRequestType_Def) + ns0.DestroyPropertyFilter_Dec.__bases__ = tuple(bases) + + ns0.DestroyPropertyFilterRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestroyPropertyFilter_Dec_Holder" + + class DestroyPropertyFilterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyPropertyFilterResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyPropertyFilterResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyPropertyFilterResponse") + kw["aname"] = "_DestroyPropertyFilterResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyPropertyFilterResponse_Holder" + self.pyclass = Holder + + class CreateFilter_Dec(ElementDeclaration): + literal = "CreateFilter" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateFilter") + kw["aname"] = "_CreateFilter" + if ns0.CreateFilterRequestType_Def not in ns0.CreateFilter_Dec.__bases__: + bases = list(ns0.CreateFilter_Dec.__bases__) + bases.insert(0, ns0.CreateFilterRequestType_Def) + ns0.CreateFilter_Dec.__bases__ = tuple(bases) + + ns0.CreateFilterRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateFilter_Dec_Holder" + + class CreateFilterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateFilterResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateFilterResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateFilterResponse") + kw["aname"] = "_CreateFilterResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateFilterResponse_Holder" + self.pyclass = Holder + + class RetrieveProperties_Dec(ElementDeclaration): + literal = "RetrieveProperties" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveProperties") + kw["aname"] = "_RetrieveProperties" + if ns0.RetrievePropertiesRequestType_Def not in ns0.RetrieveProperties_Dec.__bases__: + bases = list(ns0.RetrieveProperties_Dec.__bases__) + bases.insert(0, ns0.RetrievePropertiesRequestType_Def) + ns0.RetrieveProperties_Dec.__bases__ = tuple(bases) + + ns0.RetrievePropertiesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveProperties_Dec_Holder" + + class RetrievePropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrievePropertiesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrievePropertiesResponse_Dec.schema + TClist = [GTD("urn:vim25","ObjectContent",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrievePropertiesResponse") + kw["aname"] = "_RetrievePropertiesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrievePropertiesResponse_Holder" + self.pyclass = Holder + + class CheckForUpdates_Dec(ElementDeclaration): + literal = "CheckForUpdates" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckForUpdates") + kw["aname"] = "_CheckForUpdates" + if ns0.CheckForUpdatesRequestType_Def not in ns0.CheckForUpdates_Dec.__bases__: + bases = list(ns0.CheckForUpdates_Dec.__bases__) + bases.insert(0, ns0.CheckForUpdatesRequestType_Def) + ns0.CheckForUpdates_Dec.__bases__ = tuple(bases) + + ns0.CheckForUpdatesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckForUpdates_Dec_Holder" + + class CheckForUpdatesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckForUpdatesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckForUpdatesResponse_Dec.schema + TClist = [GTD("urn:vim25","UpdateSet",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckForUpdatesResponse") + kw["aname"] = "_CheckForUpdatesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CheckForUpdatesResponse_Holder" + self.pyclass = Holder + + class WaitForUpdates_Dec(ElementDeclaration): + literal = "WaitForUpdates" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","WaitForUpdates") + kw["aname"] = "_WaitForUpdates" + if ns0.WaitForUpdatesRequestType_Def not in ns0.WaitForUpdates_Dec.__bases__: + bases = list(ns0.WaitForUpdates_Dec.__bases__) + bases.insert(0, ns0.WaitForUpdatesRequestType_Def) + ns0.WaitForUpdates_Dec.__bases__ = tuple(bases) + + ns0.WaitForUpdatesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "WaitForUpdates_Dec_Holder" + + class WaitForUpdatesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "WaitForUpdatesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.WaitForUpdatesResponse_Dec.schema + TClist = [GTD("urn:vim25","UpdateSet",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","WaitForUpdatesResponse") + kw["aname"] = "_WaitForUpdatesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "WaitForUpdatesResponse_Holder" + self.pyclass = Holder + + class CancelWaitForUpdates_Dec(ElementDeclaration): + literal = "CancelWaitForUpdates" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CancelWaitForUpdates") + kw["aname"] = "_CancelWaitForUpdates" + if ns0.CancelWaitForUpdatesRequestType_Def not in ns0.CancelWaitForUpdates_Dec.__bases__: + bases = list(ns0.CancelWaitForUpdates_Dec.__bases__) + bases.insert(0, ns0.CancelWaitForUpdatesRequestType_Def) + ns0.CancelWaitForUpdates_Dec.__bases__ = tuple(bases) + + ns0.CancelWaitForUpdatesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CancelWaitForUpdates_Dec_Holder" + + class CancelWaitForUpdatesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CancelWaitForUpdatesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CancelWaitForUpdatesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CancelWaitForUpdatesResponse") + kw["aname"] = "_CancelWaitForUpdatesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CancelWaitForUpdatesResponse_Holder" + self.pyclass = Holder + + class MethodFaultFault_Dec(ElementDeclaration): + literal = "MethodFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MethodFaultFault") + kw["aname"] = "_MethodFaultFault" + if ns0.MethodFault_Def not in ns0.MethodFaultFault_Dec.__bases__: + bases = list(ns0.MethodFaultFault_Dec.__bases__) + bases.insert(0, ns0.MethodFault_Def) + ns0.MethodFaultFault_Dec.__bases__ = tuple(bases) + + ns0.MethodFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MethodFaultFault_Dec_Holder" + + class RuntimeFaultFault_Dec(ElementDeclaration): + literal = "RuntimeFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RuntimeFaultFault") + kw["aname"] = "_RuntimeFaultFault" + if ns0.RuntimeFault_Def not in ns0.RuntimeFaultFault_Dec.__bases__: + bases = list(ns0.RuntimeFaultFault_Dec.__bases__) + bases.insert(0, ns0.RuntimeFault_Def) + ns0.RuntimeFaultFault_Dec.__bases__ = tuple(bases) + + ns0.RuntimeFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RuntimeFaultFault_Dec_Holder" + + class AddAuthorizationRole_Dec(ElementDeclaration): + literal = "AddAuthorizationRole" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddAuthorizationRole") + kw["aname"] = "_AddAuthorizationRole" + if ns0.AddAuthorizationRoleRequestType_Def not in ns0.AddAuthorizationRole_Dec.__bases__: + bases = list(ns0.AddAuthorizationRole_Dec.__bases__) + bases.insert(0, ns0.AddAuthorizationRoleRequestType_Def) + ns0.AddAuthorizationRole_Dec.__bases__ = tuple(bases) + + ns0.AddAuthorizationRoleRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddAuthorizationRole_Dec_Holder" + + class AddAuthorizationRoleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddAuthorizationRoleResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddAuthorizationRoleResponse_Dec.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddAuthorizationRoleResponse") + kw["aname"] = "_AddAuthorizationRoleResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddAuthorizationRoleResponse_Holder" + self.pyclass = Holder + + class RemoveAuthorizationRole_Dec(ElementDeclaration): + literal = "RemoveAuthorizationRole" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveAuthorizationRole") + kw["aname"] = "_RemoveAuthorizationRole" + if ns0.RemoveAuthorizationRoleRequestType_Def not in ns0.RemoveAuthorizationRole_Dec.__bases__: + bases = list(ns0.RemoveAuthorizationRole_Dec.__bases__) + bases.insert(0, ns0.RemoveAuthorizationRoleRequestType_Def) + ns0.RemoveAuthorizationRole_Dec.__bases__ = tuple(bases) + + ns0.RemoveAuthorizationRoleRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveAuthorizationRole_Dec_Holder" + + class RemoveAuthorizationRoleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveAuthorizationRoleResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveAuthorizationRoleResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveAuthorizationRoleResponse") + kw["aname"] = "_RemoveAuthorizationRoleResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveAuthorizationRoleResponse_Holder" + self.pyclass = Holder + + class UpdateAuthorizationRole_Dec(ElementDeclaration): + literal = "UpdateAuthorizationRole" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateAuthorizationRole") + kw["aname"] = "_UpdateAuthorizationRole" + if ns0.UpdateAuthorizationRoleRequestType_Def not in ns0.UpdateAuthorizationRole_Dec.__bases__: + bases = list(ns0.UpdateAuthorizationRole_Dec.__bases__) + bases.insert(0, ns0.UpdateAuthorizationRoleRequestType_Def) + ns0.UpdateAuthorizationRole_Dec.__bases__ = tuple(bases) + + ns0.UpdateAuthorizationRoleRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateAuthorizationRole_Dec_Holder" + + class UpdateAuthorizationRoleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateAuthorizationRoleResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateAuthorizationRoleResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateAuthorizationRoleResponse") + kw["aname"] = "_UpdateAuthorizationRoleResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateAuthorizationRoleResponse_Holder" + self.pyclass = Holder + + class MergePermissions_Dec(ElementDeclaration): + literal = "MergePermissions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MergePermissions") + kw["aname"] = "_MergePermissions" + if ns0.MergePermissionsRequestType_Def not in ns0.MergePermissions_Dec.__bases__: + bases = list(ns0.MergePermissions_Dec.__bases__) + bases.insert(0, ns0.MergePermissionsRequestType_Def) + ns0.MergePermissions_Dec.__bases__ = tuple(bases) + + ns0.MergePermissionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MergePermissions_Dec_Holder" + + class MergePermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MergePermissionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MergePermissionsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MergePermissionsResponse") + kw["aname"] = "_MergePermissionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MergePermissionsResponse_Holder" + self.pyclass = Holder + + class RetrieveRolePermissions_Dec(ElementDeclaration): + literal = "RetrieveRolePermissions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveRolePermissions") + kw["aname"] = "_RetrieveRolePermissions" + if ns0.RetrieveRolePermissionsRequestType_Def not in ns0.RetrieveRolePermissions_Dec.__bases__: + bases = list(ns0.RetrieveRolePermissions_Dec.__bases__) + bases.insert(0, ns0.RetrieveRolePermissionsRequestType_Def) + ns0.RetrieveRolePermissions_Dec.__bases__ = tuple(bases) + + ns0.RetrieveRolePermissionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveRolePermissions_Dec_Holder" + + class RetrieveRolePermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveRolePermissionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveRolePermissionsResponse_Dec.schema + TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveRolePermissionsResponse") + kw["aname"] = "_RetrieveRolePermissionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveRolePermissionsResponse_Holder" + self.pyclass = Holder + + class RetrieveEntityPermissions_Dec(ElementDeclaration): + literal = "RetrieveEntityPermissions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveEntityPermissions") + kw["aname"] = "_RetrieveEntityPermissions" + if ns0.RetrieveEntityPermissionsRequestType_Def not in ns0.RetrieveEntityPermissions_Dec.__bases__: + bases = list(ns0.RetrieveEntityPermissions_Dec.__bases__) + bases.insert(0, ns0.RetrieveEntityPermissionsRequestType_Def) + ns0.RetrieveEntityPermissions_Dec.__bases__ = tuple(bases) + + ns0.RetrieveEntityPermissionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveEntityPermissions_Dec_Holder" + + class RetrieveEntityPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveEntityPermissionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveEntityPermissionsResponse_Dec.schema + TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveEntityPermissionsResponse") + kw["aname"] = "_RetrieveEntityPermissionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveEntityPermissionsResponse_Holder" + self.pyclass = Holder + + class RetrieveAllPermissions_Dec(ElementDeclaration): + literal = "RetrieveAllPermissions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveAllPermissions") + kw["aname"] = "_RetrieveAllPermissions" + if ns0.RetrieveAllPermissionsRequestType_Def not in ns0.RetrieveAllPermissions_Dec.__bases__: + bases = list(ns0.RetrieveAllPermissions_Dec.__bases__) + bases.insert(0, ns0.RetrieveAllPermissionsRequestType_Def) + ns0.RetrieveAllPermissions_Dec.__bases__ = tuple(bases) + + ns0.RetrieveAllPermissionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveAllPermissions_Dec_Holder" + + class RetrieveAllPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveAllPermissionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveAllPermissionsResponse_Dec.schema + TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveAllPermissionsResponse") + kw["aname"] = "_RetrieveAllPermissionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveAllPermissionsResponse_Holder" + self.pyclass = Holder + + class SetEntityPermissions_Dec(ElementDeclaration): + literal = "SetEntityPermissions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetEntityPermissions") + kw["aname"] = "_SetEntityPermissions" + if ns0.SetEntityPermissionsRequestType_Def not in ns0.SetEntityPermissions_Dec.__bases__: + bases = list(ns0.SetEntityPermissions_Dec.__bases__) + bases.insert(0, ns0.SetEntityPermissionsRequestType_Def) + ns0.SetEntityPermissions_Dec.__bases__ = tuple(bases) + + ns0.SetEntityPermissionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetEntityPermissions_Dec_Holder" + + class SetEntityPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetEntityPermissionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetEntityPermissionsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetEntityPermissionsResponse") + kw["aname"] = "_SetEntityPermissionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetEntityPermissionsResponse_Holder" + self.pyclass = Holder + + class ResetEntityPermissions_Dec(ElementDeclaration): + literal = "ResetEntityPermissions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetEntityPermissions") + kw["aname"] = "_ResetEntityPermissions" + if ns0.ResetEntityPermissionsRequestType_Def not in ns0.ResetEntityPermissions_Dec.__bases__: + bases = list(ns0.ResetEntityPermissions_Dec.__bases__) + bases.insert(0, ns0.ResetEntityPermissionsRequestType_Def) + ns0.ResetEntityPermissions_Dec.__bases__ = tuple(bases) + + ns0.ResetEntityPermissionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetEntityPermissions_Dec_Holder" + + class ResetEntityPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetEntityPermissionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetEntityPermissionsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetEntityPermissionsResponse") + kw["aname"] = "_ResetEntityPermissionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetEntityPermissionsResponse_Holder" + self.pyclass = Holder + + class RemoveEntityPermission_Dec(ElementDeclaration): + literal = "RemoveEntityPermission" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveEntityPermission") + kw["aname"] = "_RemoveEntityPermission" + if ns0.RemoveEntityPermissionRequestType_Def not in ns0.RemoveEntityPermission_Dec.__bases__: + bases = list(ns0.RemoveEntityPermission_Dec.__bases__) + bases.insert(0, ns0.RemoveEntityPermissionRequestType_Def) + ns0.RemoveEntityPermission_Dec.__bases__ = tuple(bases) + + ns0.RemoveEntityPermissionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveEntityPermission_Dec_Holder" + + class RemoveEntityPermissionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveEntityPermissionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveEntityPermissionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveEntityPermissionResponse") + kw["aname"] = "_RemoveEntityPermissionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveEntityPermissionResponse_Holder" + self.pyclass = Holder + + class ReconfigureCluster_Dec(ElementDeclaration): + literal = "ReconfigureCluster" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureCluster") + kw["aname"] = "_ReconfigureCluster" + if ns0.ReconfigureClusterRequestType_Def not in ns0.ReconfigureCluster_Dec.__bases__: + bases = list(ns0.ReconfigureCluster_Dec.__bases__) + bases.insert(0, ns0.ReconfigureClusterRequestType_Def) + ns0.ReconfigureCluster_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureClusterRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureCluster_Dec_Holder" + + class ReconfigureClusterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureClusterResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureClusterResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureClusterResponse") + kw["aname"] = "_ReconfigureClusterResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureClusterResponse_Holder" + self.pyclass = Holder + + class ReconfigureCluster_Task_Dec(ElementDeclaration): + literal = "ReconfigureCluster_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureCluster_Task") + kw["aname"] = "_ReconfigureCluster_Task" + if ns0.ReconfigureClusterRequestType_Def not in ns0.ReconfigureCluster_Task_Dec.__bases__: + bases = list(ns0.ReconfigureCluster_Task_Dec.__bases__) + bases.insert(0, ns0.ReconfigureClusterRequestType_Def) + ns0.ReconfigureCluster_Task_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureClusterRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureCluster_Task_Dec_Holder" + + class ReconfigureCluster_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureCluster_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureCluster_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReconfigureCluster_TaskResponse") + kw["aname"] = "_ReconfigureCluster_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ReconfigureCluster_TaskResponse_Holder" + self.pyclass = Holder + + class ApplyRecommendation_Dec(ElementDeclaration): + literal = "ApplyRecommendation" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ApplyRecommendation") + kw["aname"] = "_ApplyRecommendation" + if ns0.ApplyRecommendationRequestType_Def not in ns0.ApplyRecommendation_Dec.__bases__: + bases = list(ns0.ApplyRecommendation_Dec.__bases__) + bases.insert(0, ns0.ApplyRecommendationRequestType_Def) + ns0.ApplyRecommendation_Dec.__bases__ = tuple(bases) + + ns0.ApplyRecommendationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ApplyRecommendation_Dec_Holder" + + class ApplyRecommendationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ApplyRecommendationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ApplyRecommendationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ApplyRecommendationResponse") + kw["aname"] = "_ApplyRecommendationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ApplyRecommendationResponse_Holder" + self.pyclass = Holder + + class RecommendHostsForVm_Dec(ElementDeclaration): + literal = "RecommendHostsForVm" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RecommendHostsForVm") + kw["aname"] = "_RecommendHostsForVm" + if ns0.RecommendHostsForVmRequestType_Def not in ns0.RecommendHostsForVm_Dec.__bases__: + bases = list(ns0.RecommendHostsForVm_Dec.__bases__) + bases.insert(0, ns0.RecommendHostsForVmRequestType_Def) + ns0.RecommendHostsForVm_Dec.__bases__ = tuple(bases) + + ns0.RecommendHostsForVmRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RecommendHostsForVm_Dec_Holder" + + class RecommendHostsForVmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RecommendHostsForVmResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RecommendHostsForVmResponse_Dec.schema + TClist = [GTD("urn:vim25","ClusterHostRecommendation",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RecommendHostsForVmResponse") + kw["aname"] = "_RecommendHostsForVmResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RecommendHostsForVmResponse_Holder" + self.pyclass = Holder + + class AddHost_Dec(ElementDeclaration): + literal = "AddHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddHost") + kw["aname"] = "_AddHost" + if ns0.AddHostRequestType_Def not in ns0.AddHost_Dec.__bases__: + bases = list(ns0.AddHost_Dec.__bases__) + bases.insert(0, ns0.AddHostRequestType_Def) + ns0.AddHost_Dec.__bases__ = tuple(bases) + + ns0.AddHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddHost_Dec_Holder" + + class AddHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddHostResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddHostResponse") + kw["aname"] = "_AddHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddHostResponse_Holder" + self.pyclass = Holder + + class AddHost_Task_Dec(ElementDeclaration): + literal = "AddHost_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddHost_Task") + kw["aname"] = "_AddHost_Task" + if ns0.AddHostRequestType_Def not in ns0.AddHost_Task_Dec.__bases__: + bases = list(ns0.AddHost_Task_Dec.__bases__) + bases.insert(0, ns0.AddHostRequestType_Def) + ns0.AddHost_Task_Dec.__bases__ = tuple(bases) + + ns0.AddHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddHost_Task_Dec_Holder" + + class AddHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddHost_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddHost_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddHost_TaskResponse") + kw["aname"] = "_AddHost_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddHost_TaskResponse_Holder" + self.pyclass = Holder + + class MoveInto_Dec(ElementDeclaration): + literal = "MoveInto" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveInto") + kw["aname"] = "_MoveInto" + if ns0.MoveIntoRequestType_Def not in ns0.MoveInto_Dec.__bases__: + bases = list(ns0.MoveInto_Dec.__bases__) + bases.insert(0, ns0.MoveIntoRequestType_Def) + ns0.MoveInto_Dec.__bases__ = tuple(bases) + + ns0.MoveIntoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveInto_Dec_Holder" + + class MoveIntoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveIntoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveIntoResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MoveIntoResponse") + kw["aname"] = "_MoveIntoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MoveIntoResponse_Holder" + self.pyclass = Holder + + class MoveInto_Task_Dec(ElementDeclaration): + literal = "MoveInto_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveInto_Task") + kw["aname"] = "_MoveInto_Task" + if ns0.MoveIntoRequestType_Def not in ns0.MoveInto_Task_Dec.__bases__: + bases = list(ns0.MoveInto_Task_Dec.__bases__) + bases.insert(0, ns0.MoveIntoRequestType_Def) + ns0.MoveInto_Task_Dec.__bases__ = tuple(bases) + + ns0.MoveIntoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveInto_Task_Dec_Holder" + + class MoveInto_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveInto_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveInto_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MoveInto_TaskResponse") + kw["aname"] = "_MoveInto_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MoveInto_TaskResponse_Holder" + self.pyclass = Holder + + class MoveHostInto_Dec(ElementDeclaration): + literal = "MoveHostInto" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveHostInto") + kw["aname"] = "_MoveHostInto" + if ns0.MoveHostIntoRequestType_Def not in ns0.MoveHostInto_Dec.__bases__: + bases = list(ns0.MoveHostInto_Dec.__bases__) + bases.insert(0, ns0.MoveHostIntoRequestType_Def) + ns0.MoveHostInto_Dec.__bases__ = tuple(bases) + + ns0.MoveHostIntoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveHostInto_Dec_Holder" + + class MoveHostIntoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveHostIntoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveHostIntoResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MoveHostIntoResponse") + kw["aname"] = "_MoveHostIntoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MoveHostIntoResponse_Holder" + self.pyclass = Holder + + class MoveHostInto_Task_Dec(ElementDeclaration): + literal = "MoveHostInto_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveHostInto_Task") + kw["aname"] = "_MoveHostInto_Task" + if ns0.MoveHostIntoRequestType_Def not in ns0.MoveHostInto_Task_Dec.__bases__: + bases = list(ns0.MoveHostInto_Task_Dec.__bases__) + bases.insert(0, ns0.MoveHostIntoRequestType_Def) + ns0.MoveHostInto_Task_Dec.__bases__ = tuple(bases) + + ns0.MoveHostIntoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveHostInto_Task_Dec_Holder" + + class MoveHostInto_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveHostInto_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveHostInto_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MoveHostInto_TaskResponse") + kw["aname"] = "_MoveHostInto_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MoveHostInto_TaskResponse_Holder" + self.pyclass = Holder + + class RefreshRecommendation_Dec(ElementDeclaration): + literal = "RefreshRecommendation" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshRecommendation") + kw["aname"] = "_RefreshRecommendation" + if ns0.RefreshRecommendationRequestType_Def not in ns0.RefreshRecommendation_Dec.__bases__: + bases = list(ns0.RefreshRecommendation_Dec.__bases__) + bases.insert(0, ns0.RefreshRecommendationRequestType_Def) + ns0.RefreshRecommendation_Dec.__bases__ = tuple(bases) + + ns0.RefreshRecommendationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshRecommendation_Dec_Holder" + + class RefreshRecommendationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshRecommendationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshRecommendationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshRecommendationResponse") + kw["aname"] = "_RefreshRecommendationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshRecommendationResponse_Holder" + self.pyclass = Holder + + class RetrieveDasAdvancedRuntimeInfo_Dec(ElementDeclaration): + literal = "RetrieveDasAdvancedRuntimeInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveDasAdvancedRuntimeInfo") + kw["aname"] = "_RetrieveDasAdvancedRuntimeInfo" + if ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def not in ns0.RetrieveDasAdvancedRuntimeInfo_Dec.__bases__: + bases = list(ns0.RetrieveDasAdvancedRuntimeInfo_Dec.__bases__) + bases.insert(0, ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def) + ns0.RetrieveDasAdvancedRuntimeInfo_Dec.__bases__ = tuple(bases) + + ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveDasAdvancedRuntimeInfo_Dec_Holder" + + class RetrieveDasAdvancedRuntimeInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveDasAdvancedRuntimeInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveDasAdvancedRuntimeInfoResponse_Dec.schema + TClist = [GTD("urn:vim25","ClusterDasAdvancedRuntimeInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveDasAdvancedRuntimeInfoResponse") + kw["aname"] = "_RetrieveDasAdvancedRuntimeInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RetrieveDasAdvancedRuntimeInfoResponse_Holder" + self.pyclass = Holder + + class ReconfigureComputeResource_Dec(ElementDeclaration): + literal = "ReconfigureComputeResource" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureComputeResource") + kw["aname"] = "_ReconfigureComputeResource" + if ns0.ReconfigureComputeResourceRequestType_Def not in ns0.ReconfigureComputeResource_Dec.__bases__: + bases = list(ns0.ReconfigureComputeResource_Dec.__bases__) + bases.insert(0, ns0.ReconfigureComputeResourceRequestType_Def) + ns0.ReconfigureComputeResource_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureComputeResourceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureComputeResource_Dec_Holder" + + class ReconfigureComputeResourceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureComputeResourceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureComputeResourceResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureComputeResourceResponse") + kw["aname"] = "_ReconfigureComputeResourceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureComputeResourceResponse_Holder" + self.pyclass = Holder + + class ReconfigureComputeResource_Task_Dec(ElementDeclaration): + literal = "ReconfigureComputeResource_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureComputeResource_Task") + kw["aname"] = "_ReconfigureComputeResource_Task" + if ns0.ReconfigureComputeResourceRequestType_Def not in ns0.ReconfigureComputeResource_Task_Dec.__bases__: + bases = list(ns0.ReconfigureComputeResource_Task_Dec.__bases__) + bases.insert(0, ns0.ReconfigureComputeResourceRequestType_Def) + ns0.ReconfigureComputeResource_Task_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureComputeResourceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureComputeResource_Task_Dec_Holder" + + class ReconfigureComputeResource_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureComputeResource_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureComputeResource_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReconfigureComputeResource_TaskResponse") + kw["aname"] = "_ReconfigureComputeResource_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ReconfigureComputeResource_TaskResponse_Holder" + self.pyclass = Holder + + class AddCustomFieldDef_Dec(ElementDeclaration): + literal = "AddCustomFieldDef" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddCustomFieldDef") + kw["aname"] = "_AddCustomFieldDef" + if ns0.AddCustomFieldDefRequestType_Def not in ns0.AddCustomFieldDef_Dec.__bases__: + bases = list(ns0.AddCustomFieldDef_Dec.__bases__) + bases.insert(0, ns0.AddCustomFieldDefRequestType_Def) + ns0.AddCustomFieldDef_Dec.__bases__ = tuple(bases) + + ns0.AddCustomFieldDefRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddCustomFieldDef_Dec_Holder" + + class AddCustomFieldDefResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddCustomFieldDefResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddCustomFieldDefResponse_Dec.schema + TClist = [GTD("urn:vim25","CustomFieldDef",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddCustomFieldDefResponse") + kw["aname"] = "_AddCustomFieldDefResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddCustomFieldDefResponse_Holder" + self.pyclass = Holder + + class RemoveCustomFieldDef_Dec(ElementDeclaration): + literal = "RemoveCustomFieldDef" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveCustomFieldDef") + kw["aname"] = "_RemoveCustomFieldDef" + if ns0.RemoveCustomFieldDefRequestType_Def not in ns0.RemoveCustomFieldDef_Dec.__bases__: + bases = list(ns0.RemoveCustomFieldDef_Dec.__bases__) + bases.insert(0, ns0.RemoveCustomFieldDefRequestType_Def) + ns0.RemoveCustomFieldDef_Dec.__bases__ = tuple(bases) + + ns0.RemoveCustomFieldDefRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveCustomFieldDef_Dec_Holder" + + class RemoveCustomFieldDefResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveCustomFieldDefResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveCustomFieldDefResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveCustomFieldDefResponse") + kw["aname"] = "_RemoveCustomFieldDefResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveCustomFieldDefResponse_Holder" + self.pyclass = Holder + + class RenameCustomFieldDef_Dec(ElementDeclaration): + literal = "RenameCustomFieldDef" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RenameCustomFieldDef") + kw["aname"] = "_RenameCustomFieldDef" + if ns0.RenameCustomFieldDefRequestType_Def not in ns0.RenameCustomFieldDef_Dec.__bases__: + bases = list(ns0.RenameCustomFieldDef_Dec.__bases__) + bases.insert(0, ns0.RenameCustomFieldDefRequestType_Def) + ns0.RenameCustomFieldDef_Dec.__bases__ = tuple(bases) + + ns0.RenameCustomFieldDefRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RenameCustomFieldDef_Dec_Holder" + + class RenameCustomFieldDefResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RenameCustomFieldDefResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RenameCustomFieldDefResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RenameCustomFieldDefResponse") + kw["aname"] = "_RenameCustomFieldDefResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RenameCustomFieldDefResponse_Holder" + self.pyclass = Holder + + class SetField_Dec(ElementDeclaration): + literal = "SetField" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetField") + kw["aname"] = "_SetField" + if ns0.SetFieldRequestType_Def not in ns0.SetField_Dec.__bases__: + bases = list(ns0.SetField_Dec.__bases__) + bases.insert(0, ns0.SetFieldRequestType_Def) + ns0.SetField_Dec.__bases__ = tuple(bases) + + ns0.SetFieldRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetField_Dec_Holder" + + class SetFieldResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetFieldResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetFieldResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetFieldResponse") + kw["aname"] = "_SetFieldResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetFieldResponse_Holder" + self.pyclass = Holder + + class DoesCustomizationSpecExist_Dec(ElementDeclaration): + literal = "DoesCustomizationSpecExist" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DoesCustomizationSpecExist") + kw["aname"] = "_DoesCustomizationSpecExist" + if ns0.DoesCustomizationSpecExistRequestType_Def not in ns0.DoesCustomizationSpecExist_Dec.__bases__: + bases = list(ns0.DoesCustomizationSpecExist_Dec.__bases__) + bases.insert(0, ns0.DoesCustomizationSpecExistRequestType_Def) + ns0.DoesCustomizationSpecExist_Dec.__bases__ = tuple(bases) + + ns0.DoesCustomizationSpecExistRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DoesCustomizationSpecExist_Dec_Holder" + + class DoesCustomizationSpecExistResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DoesCustomizationSpecExistResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DoesCustomizationSpecExistResponse_Dec.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DoesCustomizationSpecExistResponse") + kw["aname"] = "_DoesCustomizationSpecExistResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DoesCustomizationSpecExistResponse_Holder" + self.pyclass = Holder + + class GetCustomizationSpec_Dec(ElementDeclaration): + literal = "GetCustomizationSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GetCustomizationSpec") + kw["aname"] = "_GetCustomizationSpec" + if ns0.GetCustomizationSpecRequestType_Def not in ns0.GetCustomizationSpec_Dec.__bases__: + bases = list(ns0.GetCustomizationSpec_Dec.__bases__) + bases.insert(0, ns0.GetCustomizationSpecRequestType_Def) + ns0.GetCustomizationSpec_Dec.__bases__ = tuple(bases) + + ns0.GetCustomizationSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GetCustomizationSpec_Dec_Holder" + + class GetCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GetCustomizationSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GetCustomizationSpecResponse_Dec.schema + TClist = [GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GetCustomizationSpecResponse") + kw["aname"] = "_GetCustomizationSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "GetCustomizationSpecResponse_Holder" + self.pyclass = Holder + + class CreateCustomizationSpec_Dec(ElementDeclaration): + literal = "CreateCustomizationSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateCustomizationSpec") + kw["aname"] = "_CreateCustomizationSpec" + if ns0.CreateCustomizationSpecRequestType_Def not in ns0.CreateCustomizationSpec_Dec.__bases__: + bases = list(ns0.CreateCustomizationSpec_Dec.__bases__) + bases.insert(0, ns0.CreateCustomizationSpecRequestType_Def) + ns0.CreateCustomizationSpec_Dec.__bases__ = tuple(bases) + + ns0.CreateCustomizationSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateCustomizationSpec_Dec_Holder" + + class CreateCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateCustomizationSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateCustomizationSpecResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CreateCustomizationSpecResponse") + kw["aname"] = "_CreateCustomizationSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CreateCustomizationSpecResponse_Holder" + self.pyclass = Holder + + class OverwriteCustomizationSpec_Dec(ElementDeclaration): + literal = "OverwriteCustomizationSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OverwriteCustomizationSpec") + kw["aname"] = "_OverwriteCustomizationSpec" + if ns0.OverwriteCustomizationSpecRequestType_Def not in ns0.OverwriteCustomizationSpec_Dec.__bases__: + bases = list(ns0.OverwriteCustomizationSpec_Dec.__bases__) + bases.insert(0, ns0.OverwriteCustomizationSpecRequestType_Def) + ns0.OverwriteCustomizationSpec_Dec.__bases__ = tuple(bases) + + ns0.OverwriteCustomizationSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OverwriteCustomizationSpec_Dec_Holder" + + class OverwriteCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "OverwriteCustomizationSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.OverwriteCustomizationSpecResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","OverwriteCustomizationSpecResponse") + kw["aname"] = "_OverwriteCustomizationSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "OverwriteCustomizationSpecResponse_Holder" + self.pyclass = Holder + + class DeleteCustomizationSpec_Dec(ElementDeclaration): + literal = "DeleteCustomizationSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeleteCustomizationSpec") + kw["aname"] = "_DeleteCustomizationSpec" + if ns0.DeleteCustomizationSpecRequestType_Def not in ns0.DeleteCustomizationSpec_Dec.__bases__: + bases = list(ns0.DeleteCustomizationSpec_Dec.__bases__) + bases.insert(0, ns0.DeleteCustomizationSpecRequestType_Def) + ns0.DeleteCustomizationSpec_Dec.__bases__ = tuple(bases) + + ns0.DeleteCustomizationSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeleteCustomizationSpec_Dec_Holder" + + class DeleteCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DeleteCustomizationSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DeleteCustomizationSpecResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DeleteCustomizationSpecResponse") + kw["aname"] = "_DeleteCustomizationSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DeleteCustomizationSpecResponse_Holder" + self.pyclass = Holder + + class DuplicateCustomizationSpec_Dec(ElementDeclaration): + literal = "DuplicateCustomizationSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DuplicateCustomizationSpec") + kw["aname"] = "_DuplicateCustomizationSpec" + if ns0.DuplicateCustomizationSpecRequestType_Def not in ns0.DuplicateCustomizationSpec_Dec.__bases__: + bases = list(ns0.DuplicateCustomizationSpec_Dec.__bases__) + bases.insert(0, ns0.DuplicateCustomizationSpecRequestType_Def) + ns0.DuplicateCustomizationSpec_Dec.__bases__ = tuple(bases) + + ns0.DuplicateCustomizationSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DuplicateCustomizationSpec_Dec_Holder" + + class DuplicateCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DuplicateCustomizationSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DuplicateCustomizationSpecResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DuplicateCustomizationSpecResponse") + kw["aname"] = "_DuplicateCustomizationSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DuplicateCustomizationSpecResponse_Holder" + self.pyclass = Holder + + class RenameCustomizationSpec_Dec(ElementDeclaration): + literal = "RenameCustomizationSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RenameCustomizationSpec") + kw["aname"] = "_RenameCustomizationSpec" + if ns0.RenameCustomizationSpecRequestType_Def not in ns0.RenameCustomizationSpec_Dec.__bases__: + bases = list(ns0.RenameCustomizationSpec_Dec.__bases__) + bases.insert(0, ns0.RenameCustomizationSpecRequestType_Def) + ns0.RenameCustomizationSpec_Dec.__bases__ = tuple(bases) + + ns0.RenameCustomizationSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RenameCustomizationSpec_Dec_Holder" + + class RenameCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RenameCustomizationSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RenameCustomizationSpecResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RenameCustomizationSpecResponse") + kw["aname"] = "_RenameCustomizationSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RenameCustomizationSpecResponse_Holder" + self.pyclass = Holder + + class CustomizationSpecItemToXml_Dec(ElementDeclaration): + literal = "CustomizationSpecItemToXml" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CustomizationSpecItemToXml") + kw["aname"] = "_CustomizationSpecItemToXml" + if ns0.CustomizationSpecItemToXmlRequestType_Def not in ns0.CustomizationSpecItemToXml_Dec.__bases__: + bases = list(ns0.CustomizationSpecItemToXml_Dec.__bases__) + bases.insert(0, ns0.CustomizationSpecItemToXmlRequestType_Def) + ns0.CustomizationSpecItemToXml_Dec.__bases__ = tuple(bases) + + ns0.CustomizationSpecItemToXmlRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CustomizationSpecItemToXml_Dec_Holder" + + class CustomizationSpecItemToXmlResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CustomizationSpecItemToXmlResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CustomizationSpecItemToXmlResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CustomizationSpecItemToXmlResponse") + kw["aname"] = "_CustomizationSpecItemToXmlResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CustomizationSpecItemToXmlResponse_Holder" + self.pyclass = Holder + + class XmlToCustomizationSpecItem_Dec(ElementDeclaration): + literal = "XmlToCustomizationSpecItem" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","XmlToCustomizationSpecItem") + kw["aname"] = "_XmlToCustomizationSpecItem" + if ns0.XmlToCustomizationSpecItemRequestType_Def not in ns0.XmlToCustomizationSpecItem_Dec.__bases__: + bases = list(ns0.XmlToCustomizationSpecItem_Dec.__bases__) + bases.insert(0, ns0.XmlToCustomizationSpecItemRequestType_Def) + ns0.XmlToCustomizationSpecItem_Dec.__bases__ = tuple(bases) + + ns0.XmlToCustomizationSpecItemRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "XmlToCustomizationSpecItem_Dec_Holder" + + class XmlToCustomizationSpecItemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "XmlToCustomizationSpecItemResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.XmlToCustomizationSpecItemResponse_Dec.schema + TClist = [GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","XmlToCustomizationSpecItemResponse") + kw["aname"] = "_XmlToCustomizationSpecItemResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "XmlToCustomizationSpecItemResponse_Holder" + self.pyclass = Holder + + class CheckCustomizationResources_Dec(ElementDeclaration): + literal = "CheckCustomizationResources" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckCustomizationResources") + kw["aname"] = "_CheckCustomizationResources" + if ns0.CheckCustomizationResourcesRequestType_Def not in ns0.CheckCustomizationResources_Dec.__bases__: + bases = list(ns0.CheckCustomizationResources_Dec.__bases__) + bases.insert(0, ns0.CheckCustomizationResourcesRequestType_Def) + ns0.CheckCustomizationResources_Dec.__bases__ = tuple(bases) + + ns0.CheckCustomizationResourcesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckCustomizationResources_Dec_Holder" + + class CheckCustomizationResourcesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckCustomizationResourcesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckCustomizationResourcesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CheckCustomizationResourcesResponse") + kw["aname"] = "_CheckCustomizationResourcesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CheckCustomizationResourcesResponse_Holder" + self.pyclass = Holder + + class QueryConnectionInfo_Dec(ElementDeclaration): + literal = "QueryConnectionInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryConnectionInfo") + kw["aname"] = "_QueryConnectionInfo" + if ns0.QueryConnectionInfoRequestType_Def not in ns0.QueryConnectionInfo_Dec.__bases__: + bases = list(ns0.QueryConnectionInfo_Dec.__bases__) + bases.insert(0, ns0.QueryConnectionInfoRequestType_Def) + ns0.QueryConnectionInfo_Dec.__bases__ = tuple(bases) + + ns0.QueryConnectionInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryConnectionInfo_Dec_Holder" + + class QueryConnectionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryConnectionInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryConnectionInfoResponse_Dec.schema + TClist = [GTD("urn:vim25","HostConnectInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryConnectionInfoResponse") + kw["aname"] = "_QueryConnectionInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryConnectionInfoResponse_Holder" + self.pyclass = Holder + + class PowerOnMultiVM_Dec(ElementDeclaration): + literal = "PowerOnMultiVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnMultiVM") + kw["aname"] = "_PowerOnMultiVM" + if ns0.PowerOnMultiVMRequestType_Def not in ns0.PowerOnMultiVM_Dec.__bases__: + bases = list(ns0.PowerOnMultiVM_Dec.__bases__) + bases.insert(0, ns0.PowerOnMultiVMRequestType_Def) + ns0.PowerOnMultiVM_Dec.__bases__ = tuple(bases) + + ns0.PowerOnMultiVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnMultiVM_Dec_Holder" + + class PowerOnMultiVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOnMultiVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOnMultiVMResponse_Dec.schema + TClist = [GTD("urn:vim25","ClusterPowerOnVmResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerOnMultiVMResponse") + kw["aname"] = "_PowerOnMultiVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerOnMultiVMResponse_Holder" + self.pyclass = Holder + + class PowerOnMultiVM_Task_Dec(ElementDeclaration): + literal = "PowerOnMultiVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnMultiVM_Task") + kw["aname"] = "_PowerOnMultiVM_Task" + if ns0.PowerOnMultiVMRequestType_Def not in ns0.PowerOnMultiVM_Task_Dec.__bases__: + bases = list(ns0.PowerOnMultiVM_Task_Dec.__bases__) + bases.insert(0, ns0.PowerOnMultiVMRequestType_Def) + ns0.PowerOnMultiVM_Task_Dec.__bases__ = tuple(bases) + + ns0.PowerOnMultiVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnMultiVM_Task_Dec_Holder" + + class PowerOnMultiVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOnMultiVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOnMultiVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerOnMultiVM_TaskResponse") + kw["aname"] = "_PowerOnMultiVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerOnMultiVM_TaskResponse_Holder" + self.pyclass = Holder + + class RefreshDatastore_Dec(ElementDeclaration): + literal = "RefreshDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshDatastore") + kw["aname"] = "_RefreshDatastore" + if ns0.RefreshDatastoreRequestType_Def not in ns0.RefreshDatastore_Dec.__bases__: + bases = list(ns0.RefreshDatastore_Dec.__bases__) + bases.insert(0, ns0.RefreshDatastoreRequestType_Def) + ns0.RefreshDatastore_Dec.__bases__ = tuple(bases) + + ns0.RefreshDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshDatastore_Dec_Holder" + + class RefreshDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshDatastoreResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshDatastoreResponse") + kw["aname"] = "_RefreshDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshDatastoreResponse_Holder" + self.pyclass = Holder + + class RefreshDatastoreStorageInfo_Dec(ElementDeclaration): + literal = "RefreshDatastoreStorageInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshDatastoreStorageInfo") + kw["aname"] = "_RefreshDatastoreStorageInfo" + if ns0.RefreshDatastoreStorageInfoRequestType_Def not in ns0.RefreshDatastoreStorageInfo_Dec.__bases__: + bases = list(ns0.RefreshDatastoreStorageInfo_Dec.__bases__) + bases.insert(0, ns0.RefreshDatastoreStorageInfoRequestType_Def) + ns0.RefreshDatastoreStorageInfo_Dec.__bases__ = tuple(bases) + + ns0.RefreshDatastoreStorageInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshDatastoreStorageInfo_Dec_Holder" + + class RefreshDatastoreStorageInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshDatastoreStorageInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshDatastoreStorageInfoResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshDatastoreStorageInfoResponse") + kw["aname"] = "_RefreshDatastoreStorageInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshDatastoreStorageInfoResponse_Holder" + self.pyclass = Holder + + class RenameDatastore_Dec(ElementDeclaration): + literal = "RenameDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RenameDatastore") + kw["aname"] = "_RenameDatastore" + if ns0.RenameDatastoreRequestType_Def not in ns0.RenameDatastore_Dec.__bases__: + bases = list(ns0.RenameDatastore_Dec.__bases__) + bases.insert(0, ns0.RenameDatastoreRequestType_Def) + ns0.RenameDatastore_Dec.__bases__ = tuple(bases) + + ns0.RenameDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RenameDatastore_Dec_Holder" + + class RenameDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RenameDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RenameDatastoreResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RenameDatastoreResponse") + kw["aname"] = "_RenameDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RenameDatastoreResponse_Holder" + self.pyclass = Holder + + class DestroyDatastore_Dec(ElementDeclaration): + literal = "DestroyDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestroyDatastore") + kw["aname"] = "_DestroyDatastore" + if ns0.DestroyDatastoreRequestType_Def not in ns0.DestroyDatastore_Dec.__bases__: + bases = list(ns0.DestroyDatastore_Dec.__bases__) + bases.insert(0, ns0.DestroyDatastoreRequestType_Def) + ns0.DestroyDatastore_Dec.__bases__ = tuple(bases) + + ns0.DestroyDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestroyDatastore_Dec_Holder" + + class DestroyDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyDatastoreResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyDatastoreResponse") + kw["aname"] = "_DestroyDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyDatastoreResponse_Holder" + self.pyclass = Holder + + class QueryDescriptions_Dec(ElementDeclaration): + literal = "QueryDescriptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryDescriptions") + kw["aname"] = "_QueryDescriptions" + if ns0.QueryDescriptionsRequestType_Def not in ns0.QueryDescriptions_Dec.__bases__: + bases = list(ns0.QueryDescriptions_Dec.__bases__) + bases.insert(0, ns0.QueryDescriptionsRequestType_Def) + ns0.QueryDescriptions_Dec.__bases__ = tuple(bases) + + ns0.QueryDescriptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryDescriptions_Dec_Holder" + + class QueryDescriptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryDescriptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryDescriptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","DiagnosticManagerLogDescriptor",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryDescriptionsResponse") + kw["aname"] = "_QueryDescriptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryDescriptionsResponse_Holder" + self.pyclass = Holder + + class BrowseDiagnosticLog_Dec(ElementDeclaration): + literal = "BrowseDiagnosticLog" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","BrowseDiagnosticLog") + kw["aname"] = "_BrowseDiagnosticLog" + if ns0.BrowseDiagnosticLogRequestType_Def not in ns0.BrowseDiagnosticLog_Dec.__bases__: + bases = list(ns0.BrowseDiagnosticLog_Dec.__bases__) + bases.insert(0, ns0.BrowseDiagnosticLogRequestType_Def) + ns0.BrowseDiagnosticLog_Dec.__bases__ = tuple(bases) + + ns0.BrowseDiagnosticLogRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "BrowseDiagnosticLog_Dec_Holder" + + class BrowseDiagnosticLogResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "BrowseDiagnosticLogResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.BrowseDiagnosticLogResponse_Dec.schema + TClist = [GTD("urn:vim25","DiagnosticManagerLogHeader",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","BrowseDiagnosticLogResponse") + kw["aname"] = "_BrowseDiagnosticLogResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "BrowseDiagnosticLogResponse_Holder" + self.pyclass = Holder + + class GenerateLogBundles_Dec(ElementDeclaration): + literal = "GenerateLogBundles" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GenerateLogBundles") + kw["aname"] = "_GenerateLogBundles" + if ns0.GenerateLogBundlesRequestType_Def not in ns0.GenerateLogBundles_Dec.__bases__: + bases = list(ns0.GenerateLogBundles_Dec.__bases__) + bases.insert(0, ns0.GenerateLogBundlesRequestType_Def) + ns0.GenerateLogBundles_Dec.__bases__ = tuple(bases) + + ns0.GenerateLogBundlesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GenerateLogBundles_Dec_Holder" + + class GenerateLogBundlesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GenerateLogBundlesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GenerateLogBundlesResponse_Dec.schema + TClist = [GTD("urn:vim25","DiagnosticManagerBundleInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GenerateLogBundlesResponse") + kw["aname"] = "_GenerateLogBundlesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "GenerateLogBundlesResponse_Holder" + self.pyclass = Holder + + class GenerateLogBundles_Task_Dec(ElementDeclaration): + literal = "GenerateLogBundles_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GenerateLogBundles_Task") + kw["aname"] = "_GenerateLogBundles_Task" + if ns0.GenerateLogBundlesRequestType_Def not in ns0.GenerateLogBundles_Task_Dec.__bases__: + bases = list(ns0.GenerateLogBundles_Task_Dec.__bases__) + bases.insert(0, ns0.GenerateLogBundlesRequestType_Def) + ns0.GenerateLogBundles_Task_Dec.__bases__ = tuple(bases) + + ns0.GenerateLogBundlesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GenerateLogBundles_Task_Dec_Holder" + + class GenerateLogBundles_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GenerateLogBundles_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GenerateLogBundles_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GenerateLogBundles_TaskResponse") + kw["aname"] = "_GenerateLogBundles_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "GenerateLogBundles_TaskResponse_Holder" + self.pyclass = Holder + + class DVSFetchKeyOfPorts_Dec(ElementDeclaration): + literal = "DVSFetchKeyOfPorts" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSFetchKeyOfPorts") + kw["aname"] = "_DVSFetchKeyOfPorts" + if ns0.DVSFetchKeyOfPortsRequestType_Def not in ns0.DVSFetchKeyOfPorts_Dec.__bases__: + bases = list(ns0.DVSFetchKeyOfPorts_Dec.__bases__) + bases.insert(0, ns0.DVSFetchKeyOfPortsRequestType_Def) + ns0.DVSFetchKeyOfPorts_Dec.__bases__ = tuple(bases) + + ns0.DVSFetchKeyOfPortsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSFetchKeyOfPorts_Dec_Holder" + + class DVSFetchKeyOfPortsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSFetchKeyOfPortsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSFetchKeyOfPortsResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSFetchKeyOfPortsResponse") + kw["aname"] = "_DVSFetchKeyOfPortsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "DVSFetchKeyOfPortsResponse_Holder" + self.pyclass = Holder + + class DVSFetchPorts_Dec(ElementDeclaration): + literal = "DVSFetchPorts" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSFetchPorts") + kw["aname"] = "_DVSFetchPorts" + if ns0.DVSFetchPortsRequestType_Def not in ns0.DVSFetchPorts_Dec.__bases__: + bases = list(ns0.DVSFetchPorts_Dec.__bases__) + bases.insert(0, ns0.DVSFetchPortsRequestType_Def) + ns0.DVSFetchPorts_Dec.__bases__ = tuple(bases) + + ns0.DVSFetchPortsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSFetchPorts_Dec_Holder" + + class DVSFetchPortsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSFetchPortsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSFetchPortsResponse_Dec.schema + TClist = [GTD("urn:vim25","DistributedVirtualPort",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSFetchPortsResponse") + kw["aname"] = "_DVSFetchPortsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "DVSFetchPortsResponse_Holder" + self.pyclass = Holder + + class DVSQueryUsedVlanId_Dec(ElementDeclaration): + literal = "DVSQueryUsedVlanId" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSQueryUsedVlanId") + kw["aname"] = "_DVSQueryUsedVlanId" + if ns0.DVSQueryUsedVlanIdRequestType_Def not in ns0.DVSQueryUsedVlanId_Dec.__bases__: + bases = list(ns0.DVSQueryUsedVlanId_Dec.__bases__) + bases.insert(0, ns0.DVSQueryUsedVlanIdRequestType_Def) + ns0.DVSQueryUsedVlanId_Dec.__bases__ = tuple(bases) + + ns0.DVSQueryUsedVlanIdRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSQueryUsedVlanId_Dec_Holder" + + class DVSQueryUsedVlanIdResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSQueryUsedVlanIdResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSQueryUsedVlanIdResponse_Dec.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSQueryUsedVlanIdResponse") + kw["aname"] = "_DVSQueryUsedVlanIdResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "DVSQueryUsedVlanIdResponse_Holder" + self.pyclass = Holder + + class DVSReconfigure_Dec(ElementDeclaration): + literal = "DVSReconfigure" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSReconfigure") + kw["aname"] = "_DVSReconfigure" + if ns0.DVSReconfigureRequestType_Def not in ns0.DVSReconfigure_Dec.__bases__: + bases = list(ns0.DVSReconfigure_Dec.__bases__) + bases.insert(0, ns0.DVSReconfigureRequestType_Def) + ns0.DVSReconfigure_Dec.__bases__ = tuple(bases) + + ns0.DVSReconfigureRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSReconfigure_Dec_Holder" + + class DVSReconfigureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSReconfigureResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSReconfigureResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSReconfigureResponse") + kw["aname"] = "_DVSReconfigureResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSReconfigureResponse_Holder" + self.pyclass = Holder + + class DVSReconfigure_Task_Dec(ElementDeclaration): + literal = "DVSReconfigure_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSReconfigure_Task") + kw["aname"] = "_DVSReconfigure_Task" + if ns0.DVSReconfigureRequestType_Def not in ns0.DVSReconfigure_Task_Dec.__bases__: + bases = list(ns0.DVSReconfigure_Task_Dec.__bases__) + bases.insert(0, ns0.DVSReconfigureRequestType_Def) + ns0.DVSReconfigure_Task_Dec.__bases__ = tuple(bases) + + ns0.DVSReconfigureRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSReconfigure_Task_Dec_Holder" + + class DVSReconfigure_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSReconfigure_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSReconfigure_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSReconfigure_TaskResponse") + kw["aname"] = "_DVSReconfigure_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DVSReconfigure_TaskResponse_Holder" + self.pyclass = Holder + + class DVSPerformProductSpecOperation_Dec(ElementDeclaration): + literal = "DVSPerformProductSpecOperation" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperation") + kw["aname"] = "_DVSPerformProductSpecOperation" + if ns0.DVSPerformProductSpecOperationRequestType_Def not in ns0.DVSPerformProductSpecOperation_Dec.__bases__: + bases = list(ns0.DVSPerformProductSpecOperation_Dec.__bases__) + bases.insert(0, ns0.DVSPerformProductSpecOperationRequestType_Def) + ns0.DVSPerformProductSpecOperation_Dec.__bases__ = tuple(bases) + + ns0.DVSPerformProductSpecOperationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSPerformProductSpecOperation_Dec_Holder" + + class DVSPerformProductSpecOperationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSPerformProductSpecOperationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSPerformProductSpecOperationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperationResponse") + kw["aname"] = "_DVSPerformProductSpecOperationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSPerformProductSpecOperationResponse_Holder" + self.pyclass = Holder + + class DVSPerformProductSpecOperation_Task_Dec(ElementDeclaration): + literal = "DVSPerformProductSpecOperation_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperation_Task") + kw["aname"] = "_DVSPerformProductSpecOperation_Task" + if ns0.DVSPerformProductSpecOperationRequestType_Def not in ns0.DVSPerformProductSpecOperation_Task_Dec.__bases__: + bases = list(ns0.DVSPerformProductSpecOperation_Task_Dec.__bases__) + bases.insert(0, ns0.DVSPerformProductSpecOperationRequestType_Def) + ns0.DVSPerformProductSpecOperation_Task_Dec.__bases__ = tuple(bases) + + ns0.DVSPerformProductSpecOperationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSPerformProductSpecOperation_Task_Dec_Holder" + + class DVSPerformProductSpecOperation_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSPerformProductSpecOperation_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSPerformProductSpecOperation_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperation_TaskResponse") + kw["aname"] = "_DVSPerformProductSpecOperation_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DVSPerformProductSpecOperation_TaskResponse_Holder" + self.pyclass = Holder + + class DVSMerge_Dec(ElementDeclaration): + literal = "DVSMerge" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSMerge") + kw["aname"] = "_DVSMerge" + if ns0.DVSMergeRequestType_Def not in ns0.DVSMerge_Dec.__bases__: + bases = list(ns0.DVSMerge_Dec.__bases__) + bases.insert(0, ns0.DVSMergeRequestType_Def) + ns0.DVSMerge_Dec.__bases__ = tuple(bases) + + ns0.DVSMergeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSMerge_Dec_Holder" + + class DVSMergeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSMergeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSMergeResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSMergeResponse") + kw["aname"] = "_DVSMergeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSMergeResponse_Holder" + self.pyclass = Holder + + class DVSMerge_Task_Dec(ElementDeclaration): + literal = "DVSMerge_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSMerge_Task") + kw["aname"] = "_DVSMerge_Task" + if ns0.DVSMergeRequestType_Def not in ns0.DVSMerge_Task_Dec.__bases__: + bases = list(ns0.DVSMerge_Task_Dec.__bases__) + bases.insert(0, ns0.DVSMergeRequestType_Def) + ns0.DVSMerge_Task_Dec.__bases__ = tuple(bases) + + ns0.DVSMergeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSMerge_Task_Dec_Holder" + + class DVSMerge_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSMerge_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSMerge_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSMerge_TaskResponse") + kw["aname"] = "_DVSMerge_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DVSMerge_TaskResponse_Holder" + self.pyclass = Holder + + class DVSAddPortgroups_Dec(ElementDeclaration): + literal = "DVSAddPortgroups" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSAddPortgroups") + kw["aname"] = "_DVSAddPortgroups" + if ns0.DVSAddPortgroupsRequestType_Def not in ns0.DVSAddPortgroups_Dec.__bases__: + bases = list(ns0.DVSAddPortgroups_Dec.__bases__) + bases.insert(0, ns0.DVSAddPortgroupsRequestType_Def) + ns0.DVSAddPortgroups_Dec.__bases__ = tuple(bases) + + ns0.DVSAddPortgroupsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSAddPortgroups_Dec_Holder" + + class DVSAddPortgroupsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSAddPortgroupsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSAddPortgroupsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSAddPortgroupsResponse") + kw["aname"] = "_DVSAddPortgroupsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSAddPortgroupsResponse_Holder" + self.pyclass = Holder + + class DVSMovePort_Dec(ElementDeclaration): + literal = "DVSMovePort" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSMovePort") + kw["aname"] = "_DVSMovePort" + if ns0.DVSMovePortRequestType_Def not in ns0.DVSMovePort_Dec.__bases__: + bases = list(ns0.DVSMovePort_Dec.__bases__) + bases.insert(0, ns0.DVSMovePortRequestType_Def) + ns0.DVSMovePort_Dec.__bases__ = tuple(bases) + + ns0.DVSMovePortRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSMovePort_Dec_Holder" + + class DVSMovePortResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSMovePortResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSMovePortResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSMovePortResponse") + kw["aname"] = "_DVSMovePortResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSMovePortResponse_Holder" + self.pyclass = Holder + + class DVSUpdateCapability_Dec(ElementDeclaration): + literal = "DVSUpdateCapability" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSUpdateCapability") + kw["aname"] = "_DVSUpdateCapability" + if ns0.DVSUpdateCapabilityRequestType_Def not in ns0.DVSUpdateCapability_Dec.__bases__: + bases = list(ns0.DVSUpdateCapability_Dec.__bases__) + bases.insert(0, ns0.DVSUpdateCapabilityRequestType_Def) + ns0.DVSUpdateCapability_Dec.__bases__ = tuple(bases) + + ns0.DVSUpdateCapabilityRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSUpdateCapability_Dec_Holder" + + class DVSUpdateCapabilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSUpdateCapabilityResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSUpdateCapabilityResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSUpdateCapabilityResponse") + kw["aname"] = "_DVSUpdateCapabilityResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSUpdateCapabilityResponse_Holder" + self.pyclass = Holder + + class ReconfigurePort_Dec(ElementDeclaration): + literal = "ReconfigurePort" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigurePort") + kw["aname"] = "_ReconfigurePort" + if ns0.ReconfigurePortRequestType_Def not in ns0.ReconfigurePort_Dec.__bases__: + bases = list(ns0.ReconfigurePort_Dec.__bases__) + bases.insert(0, ns0.ReconfigurePortRequestType_Def) + ns0.ReconfigurePort_Dec.__bases__ = tuple(bases) + + ns0.ReconfigurePortRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigurePort_Dec_Holder" + + class ReconfigurePortResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigurePortResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigurePortResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigurePortResponse") + kw["aname"] = "_ReconfigurePortResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigurePortResponse_Holder" + self.pyclass = Holder + + class DVSRefreshPortState_Dec(ElementDeclaration): + literal = "DVSRefreshPortState" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSRefreshPortState") + kw["aname"] = "_DVSRefreshPortState" + if ns0.DVSRefreshPortStateRequestType_Def not in ns0.DVSRefreshPortState_Dec.__bases__: + bases = list(ns0.DVSRefreshPortState_Dec.__bases__) + bases.insert(0, ns0.DVSRefreshPortStateRequestType_Def) + ns0.DVSRefreshPortState_Dec.__bases__ = tuple(bases) + + ns0.DVSRefreshPortStateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSRefreshPortState_Dec_Holder" + + class DVSRefreshPortStateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSRefreshPortStateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSRefreshPortStateResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSRefreshPortStateResponse") + kw["aname"] = "_DVSRefreshPortStateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSRefreshPortStateResponse_Holder" + self.pyclass = Holder + + class DVSRectifyHost_Dec(ElementDeclaration): + literal = "DVSRectifyHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSRectifyHost") + kw["aname"] = "_DVSRectifyHost" + if ns0.DVSRectifyHostRequestType_Def not in ns0.DVSRectifyHost_Dec.__bases__: + bases = list(ns0.DVSRectifyHost_Dec.__bases__) + bases.insert(0, ns0.DVSRectifyHostRequestType_Def) + ns0.DVSRectifyHost_Dec.__bases__ = tuple(bases) + + ns0.DVSRectifyHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSRectifyHost_Dec_Holder" + + class DVSRectifyHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSRectifyHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSRectifyHostResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVSRectifyHostResponse") + kw["aname"] = "_DVSRectifyHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVSRectifyHostResponse_Holder" + self.pyclass = Holder + + class QueryConfigOptionDescriptor_Dec(ElementDeclaration): + literal = "QueryConfigOptionDescriptor" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryConfigOptionDescriptor") + kw["aname"] = "_QueryConfigOptionDescriptor" + if ns0.QueryConfigOptionDescriptorRequestType_Def not in ns0.QueryConfigOptionDescriptor_Dec.__bases__: + bases = list(ns0.QueryConfigOptionDescriptor_Dec.__bases__) + bases.insert(0, ns0.QueryConfigOptionDescriptorRequestType_Def) + ns0.QueryConfigOptionDescriptor_Dec.__bases__ = tuple(bases) + + ns0.QueryConfigOptionDescriptorRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryConfigOptionDescriptor_Dec_Holder" + + class QueryConfigOptionDescriptorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryConfigOptionDescriptorResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryConfigOptionDescriptorResponse_Dec.schema + TClist = [GTD("urn:vim25","VirtualMachineConfigOptionDescriptor",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryConfigOptionDescriptorResponse") + kw["aname"] = "_QueryConfigOptionDescriptorResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryConfigOptionDescriptorResponse_Holder" + self.pyclass = Holder + + class QueryConfigOption_Dec(ElementDeclaration): + literal = "QueryConfigOption" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryConfigOption") + kw["aname"] = "_QueryConfigOption" + if ns0.QueryConfigOptionRequestType_Def not in ns0.QueryConfigOption_Dec.__bases__: + bases = list(ns0.QueryConfigOption_Dec.__bases__) + bases.insert(0, ns0.QueryConfigOptionRequestType_Def) + ns0.QueryConfigOption_Dec.__bases__ = tuple(bases) + + ns0.QueryConfigOptionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryConfigOption_Dec_Holder" + + class QueryConfigOptionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryConfigOptionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryConfigOptionResponse_Dec.schema + TClist = [GTD("urn:vim25","VirtualMachineConfigOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryConfigOptionResponse") + kw["aname"] = "_QueryConfigOptionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryConfigOptionResponse_Holder" + self.pyclass = Holder + + class QueryConfigTarget_Dec(ElementDeclaration): + literal = "QueryConfigTarget" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryConfigTarget") + kw["aname"] = "_QueryConfigTarget" + if ns0.QueryConfigTargetRequestType_Def not in ns0.QueryConfigTarget_Dec.__bases__: + bases = list(ns0.QueryConfigTarget_Dec.__bases__) + bases.insert(0, ns0.QueryConfigTargetRequestType_Def) + ns0.QueryConfigTarget_Dec.__bases__ = tuple(bases) + + ns0.QueryConfigTargetRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryConfigTarget_Dec_Holder" + + class QueryConfigTargetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryConfigTargetResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryConfigTargetResponse_Dec.schema + TClist = [GTD("urn:vim25","ConfigTarget",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryConfigTargetResponse") + kw["aname"] = "_QueryConfigTargetResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryConfigTargetResponse_Holder" + self.pyclass = Holder + + class QueryTargetCapabilities_Dec(ElementDeclaration): + literal = "QueryTargetCapabilities" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryTargetCapabilities") + kw["aname"] = "_QueryTargetCapabilities" + if ns0.QueryTargetCapabilitiesRequestType_Def not in ns0.QueryTargetCapabilities_Dec.__bases__: + bases = list(ns0.QueryTargetCapabilities_Dec.__bases__) + bases.insert(0, ns0.QueryTargetCapabilitiesRequestType_Def) + ns0.QueryTargetCapabilities_Dec.__bases__ = tuple(bases) + + ns0.QueryTargetCapabilitiesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryTargetCapabilities_Dec_Holder" + + class QueryTargetCapabilitiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryTargetCapabilitiesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryTargetCapabilitiesResponse_Dec.schema + TClist = [GTD("urn:vim25","HostCapability",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryTargetCapabilitiesResponse") + kw["aname"] = "_QueryTargetCapabilitiesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryTargetCapabilitiesResponse_Holder" + self.pyclass = Holder + + class setCustomValue_Dec(ElementDeclaration): + literal = "setCustomValue" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","setCustomValue") + kw["aname"] = "_setCustomValue" + if ns0.setCustomValueRequestType_Def not in ns0.setCustomValue_Dec.__bases__: + bases = list(ns0.setCustomValue_Dec.__bases__) + bases.insert(0, ns0.setCustomValueRequestType_Def) + ns0.setCustomValue_Dec.__bases__ = tuple(bases) + + ns0.setCustomValueRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "setCustomValue_Dec_Holder" + + class setCustomValueResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "setCustomValueResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.setCustomValueResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","setCustomValueResponse") + kw["aname"] = "_setCustomValueResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "setCustomValueResponse_Holder" + self.pyclass = Holder + + class UnregisterExtension_Dec(ElementDeclaration): + literal = "UnregisterExtension" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnregisterExtension") + kw["aname"] = "_UnregisterExtension" + if ns0.UnregisterExtensionRequestType_Def not in ns0.UnregisterExtension_Dec.__bases__: + bases = list(ns0.UnregisterExtension_Dec.__bases__) + bases.insert(0, ns0.UnregisterExtensionRequestType_Def) + ns0.UnregisterExtension_Dec.__bases__ = tuple(bases) + + ns0.UnregisterExtensionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnregisterExtension_Dec_Holder" + + class UnregisterExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UnregisterExtensionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UnregisterExtensionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UnregisterExtensionResponse") + kw["aname"] = "_UnregisterExtensionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UnregisterExtensionResponse_Holder" + self.pyclass = Holder + + class FindExtension_Dec(ElementDeclaration): + literal = "FindExtension" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindExtension") + kw["aname"] = "_FindExtension" + if ns0.FindExtensionRequestType_Def not in ns0.FindExtension_Dec.__bases__: + bases = list(ns0.FindExtension_Dec.__bases__) + bases.insert(0, ns0.FindExtensionRequestType_Def) + ns0.FindExtension_Dec.__bases__ = tuple(bases) + + ns0.FindExtensionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindExtension_Dec_Holder" + + class FindExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindExtensionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindExtensionResponse_Dec.schema + TClist = [GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindExtensionResponse") + kw["aname"] = "_FindExtensionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FindExtensionResponse_Holder" + self.pyclass = Holder + + class RegisterExtension_Dec(ElementDeclaration): + literal = "RegisterExtension" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RegisterExtension") + kw["aname"] = "_RegisterExtension" + if ns0.RegisterExtensionRequestType_Def not in ns0.RegisterExtension_Dec.__bases__: + bases = list(ns0.RegisterExtension_Dec.__bases__) + bases.insert(0, ns0.RegisterExtensionRequestType_Def) + ns0.RegisterExtension_Dec.__bases__ = tuple(bases) + + ns0.RegisterExtensionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RegisterExtension_Dec_Holder" + + class RegisterExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RegisterExtensionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RegisterExtensionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RegisterExtensionResponse") + kw["aname"] = "_RegisterExtensionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RegisterExtensionResponse_Holder" + self.pyclass = Holder + + class UpdateExtension_Dec(ElementDeclaration): + literal = "UpdateExtension" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateExtension") + kw["aname"] = "_UpdateExtension" + if ns0.UpdateExtensionRequestType_Def not in ns0.UpdateExtension_Dec.__bases__: + bases = list(ns0.UpdateExtension_Dec.__bases__) + bases.insert(0, ns0.UpdateExtensionRequestType_Def) + ns0.UpdateExtension_Dec.__bases__ = tuple(bases) + + ns0.UpdateExtensionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateExtension_Dec_Holder" + + class UpdateExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateExtensionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateExtensionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateExtensionResponse") + kw["aname"] = "_UpdateExtensionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateExtensionResponse_Holder" + self.pyclass = Holder + + class GetPublicKey_Dec(ElementDeclaration): + literal = "GetPublicKey" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GetPublicKey") + kw["aname"] = "_GetPublicKey" + if ns0.GetPublicKeyRequestType_Def not in ns0.GetPublicKey_Dec.__bases__: + bases = list(ns0.GetPublicKey_Dec.__bases__) + bases.insert(0, ns0.GetPublicKeyRequestType_Def) + ns0.GetPublicKey_Dec.__bases__ = tuple(bases) + + ns0.GetPublicKeyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GetPublicKey_Dec_Holder" + + class GetPublicKeyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GetPublicKeyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GetPublicKeyResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GetPublicKeyResponse") + kw["aname"] = "_GetPublicKeyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "GetPublicKeyResponse_Holder" + self.pyclass = Holder + + class SetPublicKey_Dec(ElementDeclaration): + literal = "SetPublicKey" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetPublicKey") + kw["aname"] = "_SetPublicKey" + if ns0.SetPublicKeyRequestType_Def not in ns0.SetPublicKey_Dec.__bases__: + bases = list(ns0.SetPublicKey_Dec.__bases__) + bases.insert(0, ns0.SetPublicKeyRequestType_Def) + ns0.SetPublicKey_Dec.__bases__ = tuple(bases) + + ns0.SetPublicKeyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetPublicKey_Dec_Holder" + + class SetPublicKeyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetPublicKeyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetPublicKeyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetPublicKeyResponse") + kw["aname"] = "_SetPublicKeyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetPublicKeyResponse_Holder" + self.pyclass = Holder + + class MoveDatastoreFile_Dec(ElementDeclaration): + literal = "MoveDatastoreFile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveDatastoreFile") + kw["aname"] = "_MoveDatastoreFile" + if ns0.MoveDatastoreFileRequestType_Def not in ns0.MoveDatastoreFile_Dec.__bases__: + bases = list(ns0.MoveDatastoreFile_Dec.__bases__) + bases.insert(0, ns0.MoveDatastoreFileRequestType_Def) + ns0.MoveDatastoreFile_Dec.__bases__ = tuple(bases) + + ns0.MoveDatastoreFileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveDatastoreFile_Dec_Holder" + + class MoveDatastoreFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveDatastoreFileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveDatastoreFileResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MoveDatastoreFileResponse") + kw["aname"] = "_MoveDatastoreFileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MoveDatastoreFileResponse_Holder" + self.pyclass = Holder + + class MoveDatastoreFile_Task_Dec(ElementDeclaration): + literal = "MoveDatastoreFile_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveDatastoreFile_Task") + kw["aname"] = "_MoveDatastoreFile_Task" + if ns0.MoveDatastoreFileRequestType_Def not in ns0.MoveDatastoreFile_Task_Dec.__bases__: + bases = list(ns0.MoveDatastoreFile_Task_Dec.__bases__) + bases.insert(0, ns0.MoveDatastoreFileRequestType_Def) + ns0.MoveDatastoreFile_Task_Dec.__bases__ = tuple(bases) + + ns0.MoveDatastoreFileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveDatastoreFile_Task_Dec_Holder" + + class MoveDatastoreFile_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveDatastoreFile_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveDatastoreFile_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MoveDatastoreFile_TaskResponse") + kw["aname"] = "_MoveDatastoreFile_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MoveDatastoreFile_TaskResponse_Holder" + self.pyclass = Holder + + class CopyDatastoreFile_Dec(ElementDeclaration): + literal = "CopyDatastoreFile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CopyDatastoreFile") + kw["aname"] = "_CopyDatastoreFile" + if ns0.CopyDatastoreFileRequestType_Def not in ns0.CopyDatastoreFile_Dec.__bases__: + bases = list(ns0.CopyDatastoreFile_Dec.__bases__) + bases.insert(0, ns0.CopyDatastoreFileRequestType_Def) + ns0.CopyDatastoreFile_Dec.__bases__ = tuple(bases) + + ns0.CopyDatastoreFileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CopyDatastoreFile_Dec_Holder" + + class CopyDatastoreFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CopyDatastoreFileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CopyDatastoreFileResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CopyDatastoreFileResponse") + kw["aname"] = "_CopyDatastoreFileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CopyDatastoreFileResponse_Holder" + self.pyclass = Holder + + class CopyDatastoreFile_Task_Dec(ElementDeclaration): + literal = "CopyDatastoreFile_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CopyDatastoreFile_Task") + kw["aname"] = "_CopyDatastoreFile_Task" + if ns0.CopyDatastoreFileRequestType_Def not in ns0.CopyDatastoreFile_Task_Dec.__bases__: + bases = list(ns0.CopyDatastoreFile_Task_Dec.__bases__) + bases.insert(0, ns0.CopyDatastoreFileRequestType_Def) + ns0.CopyDatastoreFile_Task_Dec.__bases__ = tuple(bases) + + ns0.CopyDatastoreFileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CopyDatastoreFile_Task_Dec_Holder" + + class CopyDatastoreFile_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CopyDatastoreFile_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CopyDatastoreFile_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CopyDatastoreFile_TaskResponse") + kw["aname"] = "_CopyDatastoreFile_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CopyDatastoreFile_TaskResponse_Holder" + self.pyclass = Holder + + class DeleteDatastoreFile_Dec(ElementDeclaration): + literal = "DeleteDatastoreFile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeleteDatastoreFile") + kw["aname"] = "_DeleteDatastoreFile" + if ns0.DeleteDatastoreFileRequestType_Def not in ns0.DeleteDatastoreFile_Dec.__bases__: + bases = list(ns0.DeleteDatastoreFile_Dec.__bases__) + bases.insert(0, ns0.DeleteDatastoreFileRequestType_Def) + ns0.DeleteDatastoreFile_Dec.__bases__ = tuple(bases) + + ns0.DeleteDatastoreFileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeleteDatastoreFile_Dec_Holder" + + class DeleteDatastoreFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DeleteDatastoreFileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DeleteDatastoreFileResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DeleteDatastoreFileResponse") + kw["aname"] = "_DeleteDatastoreFileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DeleteDatastoreFileResponse_Holder" + self.pyclass = Holder + + class DeleteDatastoreFile_Task_Dec(ElementDeclaration): + literal = "DeleteDatastoreFile_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeleteDatastoreFile_Task") + kw["aname"] = "_DeleteDatastoreFile_Task" + if ns0.DeleteDatastoreFileRequestType_Def not in ns0.DeleteDatastoreFile_Task_Dec.__bases__: + bases = list(ns0.DeleteDatastoreFile_Task_Dec.__bases__) + bases.insert(0, ns0.DeleteDatastoreFileRequestType_Def) + ns0.DeleteDatastoreFile_Task_Dec.__bases__ = tuple(bases) + + ns0.DeleteDatastoreFileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeleteDatastoreFile_Task_Dec_Holder" + + class DeleteDatastoreFile_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DeleteDatastoreFile_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DeleteDatastoreFile_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DeleteDatastoreFile_TaskResponse") + kw["aname"] = "_DeleteDatastoreFile_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DeleteDatastoreFile_TaskResponse_Holder" + self.pyclass = Holder + + class MakeDirectory_Dec(ElementDeclaration): + literal = "MakeDirectory" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MakeDirectory") + kw["aname"] = "_MakeDirectory" + if ns0.MakeDirectoryRequestType_Def not in ns0.MakeDirectory_Dec.__bases__: + bases = list(ns0.MakeDirectory_Dec.__bases__) + bases.insert(0, ns0.MakeDirectoryRequestType_Def) + ns0.MakeDirectory_Dec.__bases__ = tuple(bases) + + ns0.MakeDirectoryRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MakeDirectory_Dec_Holder" + + class MakeDirectoryResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MakeDirectoryResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MakeDirectoryResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MakeDirectoryResponse") + kw["aname"] = "_MakeDirectoryResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MakeDirectoryResponse_Holder" + self.pyclass = Holder + + class ChangeOwner_Dec(ElementDeclaration): + literal = "ChangeOwner" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ChangeOwner") + kw["aname"] = "_ChangeOwner" + if ns0.ChangeOwnerRequestType_Def not in ns0.ChangeOwner_Dec.__bases__: + bases = list(ns0.ChangeOwner_Dec.__bases__) + bases.insert(0, ns0.ChangeOwnerRequestType_Def) + ns0.ChangeOwner_Dec.__bases__ = tuple(bases) + + ns0.ChangeOwnerRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ChangeOwner_Dec_Holder" + + class ChangeOwnerResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ChangeOwnerResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ChangeOwnerResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ChangeOwnerResponse") + kw["aname"] = "_ChangeOwnerResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ChangeOwnerResponse_Holder" + self.pyclass = Holder + + class CreateFolder_Dec(ElementDeclaration): + literal = "CreateFolder" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateFolder") + kw["aname"] = "_CreateFolder" + if ns0.CreateFolderRequestType_Def not in ns0.CreateFolder_Dec.__bases__: + bases = list(ns0.CreateFolder_Dec.__bases__) + bases.insert(0, ns0.CreateFolderRequestType_Def) + ns0.CreateFolder_Dec.__bases__ = tuple(bases) + + ns0.CreateFolderRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateFolder_Dec_Holder" + + class CreateFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateFolderResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateFolderResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateFolderResponse") + kw["aname"] = "_CreateFolderResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateFolderResponse_Holder" + self.pyclass = Holder + + class MoveIntoFolder_Dec(ElementDeclaration): + literal = "MoveIntoFolder" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveIntoFolder") + kw["aname"] = "_MoveIntoFolder" + if ns0.MoveIntoFolderRequestType_Def not in ns0.MoveIntoFolder_Dec.__bases__: + bases = list(ns0.MoveIntoFolder_Dec.__bases__) + bases.insert(0, ns0.MoveIntoFolderRequestType_Def) + ns0.MoveIntoFolder_Dec.__bases__ = tuple(bases) + + ns0.MoveIntoFolderRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveIntoFolder_Dec_Holder" + + class MoveIntoFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveIntoFolderResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveIntoFolderResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MoveIntoFolderResponse") + kw["aname"] = "_MoveIntoFolderResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MoveIntoFolderResponse_Holder" + self.pyclass = Holder + + class MoveIntoFolder_Task_Dec(ElementDeclaration): + literal = "MoveIntoFolder_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveIntoFolder_Task") + kw["aname"] = "_MoveIntoFolder_Task" + if ns0.MoveIntoFolderRequestType_Def not in ns0.MoveIntoFolder_Task_Dec.__bases__: + bases = list(ns0.MoveIntoFolder_Task_Dec.__bases__) + bases.insert(0, ns0.MoveIntoFolderRequestType_Def) + ns0.MoveIntoFolder_Task_Dec.__bases__ = tuple(bases) + + ns0.MoveIntoFolderRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveIntoFolder_Task_Dec_Holder" + + class MoveIntoFolder_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveIntoFolder_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveIntoFolder_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MoveIntoFolder_TaskResponse") + kw["aname"] = "_MoveIntoFolder_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MoveIntoFolder_TaskResponse_Holder" + self.pyclass = Holder + + class CreateVM_Dec(ElementDeclaration): + literal = "CreateVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateVM") + kw["aname"] = "_CreateVM" + if ns0.CreateVMRequestType_Def not in ns0.CreateVM_Dec.__bases__: + bases = list(ns0.CreateVM_Dec.__bases__) + bases.insert(0, ns0.CreateVMRequestType_Def) + ns0.CreateVM_Dec.__bases__ = tuple(bases) + + ns0.CreateVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateVM_Dec_Holder" + + class CreateVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateVMResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateVMResponse") + kw["aname"] = "_CreateVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateVMResponse_Holder" + self.pyclass = Holder + + class CreateVM_Task_Dec(ElementDeclaration): + literal = "CreateVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateVM_Task") + kw["aname"] = "_CreateVM_Task" + if ns0.CreateVMRequestType_Def not in ns0.CreateVM_Task_Dec.__bases__: + bases = list(ns0.CreateVM_Task_Dec.__bases__) + bases.insert(0, ns0.CreateVMRequestType_Def) + ns0.CreateVM_Task_Dec.__bases__ = tuple(bases) + + ns0.CreateVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateVM_Task_Dec_Holder" + + class CreateVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateVM_TaskResponse") + kw["aname"] = "_CreateVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateVM_TaskResponse_Holder" + self.pyclass = Holder + + class RegisterVM_Dec(ElementDeclaration): + literal = "RegisterVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RegisterVM") + kw["aname"] = "_RegisterVM" + if ns0.RegisterVMRequestType_Def not in ns0.RegisterVM_Dec.__bases__: + bases = list(ns0.RegisterVM_Dec.__bases__) + bases.insert(0, ns0.RegisterVMRequestType_Def) + ns0.RegisterVM_Dec.__bases__ = tuple(bases) + + ns0.RegisterVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RegisterVM_Dec_Holder" + + class RegisterVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RegisterVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RegisterVMResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RegisterVMResponse") + kw["aname"] = "_RegisterVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RegisterVMResponse_Holder" + self.pyclass = Holder + + class RegisterVM_Task_Dec(ElementDeclaration): + literal = "RegisterVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RegisterVM_Task") + kw["aname"] = "_RegisterVM_Task" + if ns0.RegisterVMRequestType_Def not in ns0.RegisterVM_Task_Dec.__bases__: + bases = list(ns0.RegisterVM_Task_Dec.__bases__) + bases.insert(0, ns0.RegisterVMRequestType_Def) + ns0.RegisterVM_Task_Dec.__bases__ = tuple(bases) + + ns0.RegisterVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RegisterVM_Task_Dec_Holder" + + class RegisterVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RegisterVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RegisterVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RegisterVM_TaskResponse") + kw["aname"] = "_RegisterVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RegisterVM_TaskResponse_Holder" + self.pyclass = Holder + + class CreateCluster_Dec(ElementDeclaration): + literal = "CreateCluster" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateCluster") + kw["aname"] = "_CreateCluster" + if ns0.CreateClusterRequestType_Def not in ns0.CreateCluster_Dec.__bases__: + bases = list(ns0.CreateCluster_Dec.__bases__) + bases.insert(0, ns0.CreateClusterRequestType_Def) + ns0.CreateCluster_Dec.__bases__ = tuple(bases) + + ns0.CreateClusterRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateCluster_Dec_Holder" + + class CreateClusterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateClusterResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateClusterResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateClusterResponse") + kw["aname"] = "_CreateClusterResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateClusterResponse_Holder" + self.pyclass = Holder + + class CreateClusterEx_Dec(ElementDeclaration): + literal = "CreateClusterEx" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateClusterEx") + kw["aname"] = "_CreateClusterEx" + if ns0.CreateClusterExRequestType_Def not in ns0.CreateClusterEx_Dec.__bases__: + bases = list(ns0.CreateClusterEx_Dec.__bases__) + bases.insert(0, ns0.CreateClusterExRequestType_Def) + ns0.CreateClusterEx_Dec.__bases__ = tuple(bases) + + ns0.CreateClusterExRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateClusterEx_Dec_Holder" + + class CreateClusterExResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateClusterExResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateClusterExResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateClusterExResponse") + kw["aname"] = "_CreateClusterExResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateClusterExResponse_Holder" + self.pyclass = Holder + + class AddStandaloneHost_Dec(ElementDeclaration): + literal = "AddStandaloneHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddStandaloneHost") + kw["aname"] = "_AddStandaloneHost" + if ns0.AddStandaloneHostRequestType_Def not in ns0.AddStandaloneHost_Dec.__bases__: + bases = list(ns0.AddStandaloneHost_Dec.__bases__) + bases.insert(0, ns0.AddStandaloneHostRequestType_Def) + ns0.AddStandaloneHost_Dec.__bases__ = tuple(bases) + + ns0.AddStandaloneHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddStandaloneHost_Dec_Holder" + + class AddStandaloneHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddStandaloneHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddStandaloneHostResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddStandaloneHostResponse") + kw["aname"] = "_AddStandaloneHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddStandaloneHostResponse_Holder" + self.pyclass = Holder + + class AddStandaloneHost_Task_Dec(ElementDeclaration): + literal = "AddStandaloneHost_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddStandaloneHost_Task") + kw["aname"] = "_AddStandaloneHost_Task" + if ns0.AddStandaloneHostRequestType_Def not in ns0.AddStandaloneHost_Task_Dec.__bases__: + bases = list(ns0.AddStandaloneHost_Task_Dec.__bases__) + bases.insert(0, ns0.AddStandaloneHostRequestType_Def) + ns0.AddStandaloneHost_Task_Dec.__bases__ = tuple(bases) + + ns0.AddStandaloneHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddStandaloneHost_Task_Dec_Holder" + + class AddStandaloneHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddStandaloneHost_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddStandaloneHost_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddStandaloneHost_TaskResponse") + kw["aname"] = "_AddStandaloneHost_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddStandaloneHost_TaskResponse_Holder" + self.pyclass = Holder + + class CreateDatacenter_Dec(ElementDeclaration): + literal = "CreateDatacenter" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateDatacenter") + kw["aname"] = "_CreateDatacenter" + if ns0.CreateDatacenterRequestType_Def not in ns0.CreateDatacenter_Dec.__bases__: + bases = list(ns0.CreateDatacenter_Dec.__bases__) + bases.insert(0, ns0.CreateDatacenterRequestType_Def) + ns0.CreateDatacenter_Dec.__bases__ = tuple(bases) + + ns0.CreateDatacenterRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateDatacenter_Dec_Holder" + + class CreateDatacenterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateDatacenterResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateDatacenterResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateDatacenterResponse") + kw["aname"] = "_CreateDatacenterResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateDatacenterResponse_Holder" + self.pyclass = Holder + + class UnregisterAndDestroy_Dec(ElementDeclaration): + literal = "UnregisterAndDestroy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnregisterAndDestroy") + kw["aname"] = "_UnregisterAndDestroy" + if ns0.UnregisterAndDestroyRequestType_Def not in ns0.UnregisterAndDestroy_Dec.__bases__: + bases = list(ns0.UnregisterAndDestroy_Dec.__bases__) + bases.insert(0, ns0.UnregisterAndDestroyRequestType_Def) + ns0.UnregisterAndDestroy_Dec.__bases__ = tuple(bases) + + ns0.UnregisterAndDestroyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnregisterAndDestroy_Dec_Holder" + + class UnregisterAndDestroyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UnregisterAndDestroyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UnregisterAndDestroyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UnregisterAndDestroyResponse") + kw["aname"] = "_UnregisterAndDestroyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UnregisterAndDestroyResponse_Holder" + self.pyclass = Holder + + class UnregisterAndDestroy_Task_Dec(ElementDeclaration): + literal = "UnregisterAndDestroy_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnregisterAndDestroy_Task") + kw["aname"] = "_UnregisterAndDestroy_Task" + if ns0.UnregisterAndDestroyRequestType_Def not in ns0.UnregisterAndDestroy_Task_Dec.__bases__: + bases = list(ns0.UnregisterAndDestroy_Task_Dec.__bases__) + bases.insert(0, ns0.UnregisterAndDestroyRequestType_Def) + ns0.UnregisterAndDestroy_Task_Dec.__bases__ = tuple(bases) + + ns0.UnregisterAndDestroyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnregisterAndDestroy_Task_Dec_Holder" + + class UnregisterAndDestroy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UnregisterAndDestroy_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UnregisterAndDestroy_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UnregisterAndDestroy_TaskResponse") + kw["aname"] = "_UnregisterAndDestroy_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UnregisterAndDestroy_TaskResponse_Holder" + self.pyclass = Holder + + class FolderCreateDVS_Dec(ElementDeclaration): + literal = "FolderCreateDVS" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FolderCreateDVS") + kw["aname"] = "_FolderCreateDVS" + if ns0.FolderCreateDVSRequestType_Def not in ns0.FolderCreateDVS_Dec.__bases__: + bases = list(ns0.FolderCreateDVS_Dec.__bases__) + bases.insert(0, ns0.FolderCreateDVSRequestType_Def) + ns0.FolderCreateDVS_Dec.__bases__ = tuple(bases) + + ns0.FolderCreateDVSRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FolderCreateDVS_Dec_Holder" + + class FolderCreateDVSResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FolderCreateDVSResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FolderCreateDVSResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FolderCreateDVSResponse") + kw["aname"] = "_FolderCreateDVSResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FolderCreateDVSResponse_Holder" + self.pyclass = Holder + + class SetCollectorPageSize_Dec(ElementDeclaration): + literal = "SetCollectorPageSize" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetCollectorPageSize") + kw["aname"] = "_SetCollectorPageSize" + if ns0.SetCollectorPageSizeRequestType_Def not in ns0.SetCollectorPageSize_Dec.__bases__: + bases = list(ns0.SetCollectorPageSize_Dec.__bases__) + bases.insert(0, ns0.SetCollectorPageSizeRequestType_Def) + ns0.SetCollectorPageSize_Dec.__bases__ = tuple(bases) + + ns0.SetCollectorPageSizeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetCollectorPageSize_Dec_Holder" + + class SetCollectorPageSizeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetCollectorPageSizeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetCollectorPageSizeResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetCollectorPageSizeResponse") + kw["aname"] = "_SetCollectorPageSizeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetCollectorPageSizeResponse_Holder" + self.pyclass = Holder + + class RewindCollector_Dec(ElementDeclaration): + literal = "RewindCollector" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RewindCollector") + kw["aname"] = "_RewindCollector" + if ns0.RewindCollectorRequestType_Def not in ns0.RewindCollector_Dec.__bases__: + bases = list(ns0.RewindCollector_Dec.__bases__) + bases.insert(0, ns0.RewindCollectorRequestType_Def) + ns0.RewindCollector_Dec.__bases__ = tuple(bases) + + ns0.RewindCollectorRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RewindCollector_Dec_Holder" + + class RewindCollectorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RewindCollectorResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RewindCollectorResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RewindCollectorResponse") + kw["aname"] = "_RewindCollectorResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RewindCollectorResponse_Holder" + self.pyclass = Holder + + class ResetCollector_Dec(ElementDeclaration): + literal = "ResetCollector" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetCollector") + kw["aname"] = "_ResetCollector" + if ns0.ResetCollectorRequestType_Def not in ns0.ResetCollector_Dec.__bases__: + bases = list(ns0.ResetCollector_Dec.__bases__) + bases.insert(0, ns0.ResetCollectorRequestType_Def) + ns0.ResetCollector_Dec.__bases__ = tuple(bases) + + ns0.ResetCollectorRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetCollector_Dec_Holder" + + class ResetCollectorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetCollectorResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetCollectorResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetCollectorResponse") + kw["aname"] = "_ResetCollectorResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetCollectorResponse_Holder" + self.pyclass = Holder + + class DestroyCollector_Dec(ElementDeclaration): + literal = "DestroyCollector" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestroyCollector") + kw["aname"] = "_DestroyCollector" + if ns0.DestroyCollectorRequestType_Def not in ns0.DestroyCollector_Dec.__bases__: + bases = list(ns0.DestroyCollector_Dec.__bases__) + bases.insert(0, ns0.DestroyCollectorRequestType_Def) + ns0.DestroyCollector_Dec.__bases__ = tuple(bases) + + ns0.DestroyCollectorRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestroyCollector_Dec_Holder" + + class DestroyCollectorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyCollectorResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyCollectorResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyCollectorResponse") + kw["aname"] = "_DestroyCollectorResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyCollectorResponse_Holder" + self.pyclass = Holder + + class QueryHostConnectionInfo_Dec(ElementDeclaration): + literal = "QueryHostConnectionInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryHostConnectionInfo") + kw["aname"] = "_QueryHostConnectionInfo" + if ns0.QueryHostConnectionInfoRequestType_Def not in ns0.QueryHostConnectionInfo_Dec.__bases__: + bases = list(ns0.QueryHostConnectionInfo_Dec.__bases__) + bases.insert(0, ns0.QueryHostConnectionInfoRequestType_Def) + ns0.QueryHostConnectionInfo_Dec.__bases__ = tuple(bases) + + ns0.QueryHostConnectionInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryHostConnectionInfo_Dec_Holder" + + class QueryHostConnectionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryHostConnectionInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryHostConnectionInfoResponse_Dec.schema + TClist = [GTD("urn:vim25","HostConnectInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryHostConnectionInfoResponse") + kw["aname"] = "_QueryHostConnectionInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryHostConnectionInfoResponse_Holder" + self.pyclass = Holder + + class UpdateSystemResources_Dec(ElementDeclaration): + literal = "UpdateSystemResources" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateSystemResources") + kw["aname"] = "_UpdateSystemResources" + if ns0.UpdateSystemResourcesRequestType_Def not in ns0.UpdateSystemResources_Dec.__bases__: + bases = list(ns0.UpdateSystemResources_Dec.__bases__) + bases.insert(0, ns0.UpdateSystemResourcesRequestType_Def) + ns0.UpdateSystemResources_Dec.__bases__ = tuple(bases) + + ns0.UpdateSystemResourcesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateSystemResources_Dec_Holder" + + class UpdateSystemResourcesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateSystemResourcesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateSystemResourcesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateSystemResourcesResponse") + kw["aname"] = "_UpdateSystemResourcesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateSystemResourcesResponse_Holder" + self.pyclass = Holder + + class ReconnectHost_Dec(ElementDeclaration): + literal = "ReconnectHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconnectHost") + kw["aname"] = "_ReconnectHost" + if ns0.ReconnectHostRequestType_Def not in ns0.ReconnectHost_Dec.__bases__: + bases = list(ns0.ReconnectHost_Dec.__bases__) + bases.insert(0, ns0.ReconnectHostRequestType_Def) + ns0.ReconnectHost_Dec.__bases__ = tuple(bases) + + ns0.ReconnectHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconnectHost_Dec_Holder" + + class ReconnectHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconnectHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconnectHostResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconnectHostResponse") + kw["aname"] = "_ReconnectHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconnectHostResponse_Holder" + self.pyclass = Holder + + class ReconnectHost_Task_Dec(ElementDeclaration): + literal = "ReconnectHost_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconnectHost_Task") + kw["aname"] = "_ReconnectHost_Task" + if ns0.ReconnectHostRequestType_Def not in ns0.ReconnectHost_Task_Dec.__bases__: + bases = list(ns0.ReconnectHost_Task_Dec.__bases__) + bases.insert(0, ns0.ReconnectHostRequestType_Def) + ns0.ReconnectHost_Task_Dec.__bases__ = tuple(bases) + + ns0.ReconnectHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconnectHost_Task_Dec_Holder" + + class ReconnectHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconnectHost_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconnectHost_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReconnectHost_TaskResponse") + kw["aname"] = "_ReconnectHost_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ReconnectHost_TaskResponse_Holder" + self.pyclass = Holder + + class DisconnectHost_Dec(ElementDeclaration): + literal = "DisconnectHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisconnectHost") + kw["aname"] = "_DisconnectHost" + if ns0.DisconnectHostRequestType_Def not in ns0.DisconnectHost_Dec.__bases__: + bases = list(ns0.DisconnectHost_Dec.__bases__) + bases.insert(0, ns0.DisconnectHostRequestType_Def) + ns0.DisconnectHost_Dec.__bases__ = tuple(bases) + + ns0.DisconnectHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisconnectHost_Dec_Holder" + + class DisconnectHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisconnectHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisconnectHostResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DisconnectHostResponse") + kw["aname"] = "_DisconnectHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DisconnectHostResponse_Holder" + self.pyclass = Holder + + class DisconnectHost_Task_Dec(ElementDeclaration): + literal = "DisconnectHost_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisconnectHost_Task") + kw["aname"] = "_DisconnectHost_Task" + if ns0.DisconnectHostRequestType_Def not in ns0.DisconnectHost_Task_Dec.__bases__: + bases = list(ns0.DisconnectHost_Task_Dec.__bases__) + bases.insert(0, ns0.DisconnectHostRequestType_Def) + ns0.DisconnectHost_Task_Dec.__bases__ = tuple(bases) + + ns0.DisconnectHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisconnectHost_Task_Dec_Holder" + + class DisconnectHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisconnectHost_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisconnectHost_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DisconnectHost_TaskResponse") + kw["aname"] = "_DisconnectHost_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DisconnectHost_TaskResponse_Holder" + self.pyclass = Holder + + class EnterMaintenanceMode_Dec(ElementDeclaration): + literal = "EnterMaintenanceMode" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnterMaintenanceMode") + kw["aname"] = "_EnterMaintenanceMode" + if ns0.EnterMaintenanceModeRequestType_Def not in ns0.EnterMaintenanceMode_Dec.__bases__: + bases = list(ns0.EnterMaintenanceMode_Dec.__bases__) + bases.insert(0, ns0.EnterMaintenanceModeRequestType_Def) + ns0.EnterMaintenanceMode_Dec.__bases__ = tuple(bases) + + ns0.EnterMaintenanceModeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnterMaintenanceMode_Dec_Holder" + + class EnterMaintenanceModeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnterMaintenanceModeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnterMaintenanceModeResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","EnterMaintenanceModeResponse") + kw["aname"] = "_EnterMaintenanceModeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "EnterMaintenanceModeResponse_Holder" + self.pyclass = Holder + + class EnterMaintenanceMode_Task_Dec(ElementDeclaration): + literal = "EnterMaintenanceMode_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnterMaintenanceMode_Task") + kw["aname"] = "_EnterMaintenanceMode_Task" + if ns0.EnterMaintenanceModeRequestType_Def not in ns0.EnterMaintenanceMode_Task_Dec.__bases__: + bases = list(ns0.EnterMaintenanceMode_Task_Dec.__bases__) + bases.insert(0, ns0.EnterMaintenanceModeRequestType_Def) + ns0.EnterMaintenanceMode_Task_Dec.__bases__ = tuple(bases) + + ns0.EnterMaintenanceModeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnterMaintenanceMode_Task_Dec_Holder" + + class EnterMaintenanceMode_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnterMaintenanceMode_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnterMaintenanceMode_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","EnterMaintenanceMode_TaskResponse") + kw["aname"] = "_EnterMaintenanceMode_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "EnterMaintenanceMode_TaskResponse_Holder" + self.pyclass = Holder + + class ExitMaintenanceMode_Dec(ElementDeclaration): + literal = "ExitMaintenanceMode" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExitMaintenanceMode") + kw["aname"] = "_ExitMaintenanceMode" + if ns0.ExitMaintenanceModeRequestType_Def not in ns0.ExitMaintenanceMode_Dec.__bases__: + bases = list(ns0.ExitMaintenanceMode_Dec.__bases__) + bases.insert(0, ns0.ExitMaintenanceModeRequestType_Def) + ns0.ExitMaintenanceMode_Dec.__bases__ = tuple(bases) + + ns0.ExitMaintenanceModeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExitMaintenanceMode_Dec_Holder" + + class ExitMaintenanceModeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExitMaintenanceModeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExitMaintenanceModeResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ExitMaintenanceModeResponse") + kw["aname"] = "_ExitMaintenanceModeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ExitMaintenanceModeResponse_Holder" + self.pyclass = Holder + + class ExitMaintenanceMode_Task_Dec(ElementDeclaration): + literal = "ExitMaintenanceMode_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExitMaintenanceMode_Task") + kw["aname"] = "_ExitMaintenanceMode_Task" + if ns0.ExitMaintenanceModeRequestType_Def not in ns0.ExitMaintenanceMode_Task_Dec.__bases__: + bases = list(ns0.ExitMaintenanceMode_Task_Dec.__bases__) + bases.insert(0, ns0.ExitMaintenanceModeRequestType_Def) + ns0.ExitMaintenanceMode_Task_Dec.__bases__ = tuple(bases) + + ns0.ExitMaintenanceModeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExitMaintenanceMode_Task_Dec_Holder" + + class ExitMaintenanceMode_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExitMaintenanceMode_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExitMaintenanceMode_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ExitMaintenanceMode_TaskResponse") + kw["aname"] = "_ExitMaintenanceMode_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ExitMaintenanceMode_TaskResponse_Holder" + self.pyclass = Holder + + class RebootHost_Dec(ElementDeclaration): + literal = "RebootHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RebootHost") + kw["aname"] = "_RebootHost" + if ns0.RebootHostRequestType_Def not in ns0.RebootHost_Dec.__bases__: + bases = list(ns0.RebootHost_Dec.__bases__) + bases.insert(0, ns0.RebootHostRequestType_Def) + ns0.RebootHost_Dec.__bases__ = tuple(bases) + + ns0.RebootHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RebootHost_Dec_Holder" + + class RebootHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RebootHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RebootHostResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RebootHostResponse") + kw["aname"] = "_RebootHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RebootHostResponse_Holder" + self.pyclass = Holder + + class RebootHost_Task_Dec(ElementDeclaration): + literal = "RebootHost_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RebootHost_Task") + kw["aname"] = "_RebootHost_Task" + if ns0.RebootHostRequestType_Def not in ns0.RebootHost_Task_Dec.__bases__: + bases = list(ns0.RebootHost_Task_Dec.__bases__) + bases.insert(0, ns0.RebootHostRequestType_Def) + ns0.RebootHost_Task_Dec.__bases__ = tuple(bases) + + ns0.RebootHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RebootHost_Task_Dec_Holder" + + class RebootHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RebootHost_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RebootHost_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RebootHost_TaskResponse") + kw["aname"] = "_RebootHost_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RebootHost_TaskResponse_Holder" + self.pyclass = Holder + + class ShutdownHost_Dec(ElementDeclaration): + literal = "ShutdownHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ShutdownHost") + kw["aname"] = "_ShutdownHost" + if ns0.ShutdownHostRequestType_Def not in ns0.ShutdownHost_Dec.__bases__: + bases = list(ns0.ShutdownHost_Dec.__bases__) + bases.insert(0, ns0.ShutdownHostRequestType_Def) + ns0.ShutdownHost_Dec.__bases__ = tuple(bases) + + ns0.ShutdownHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ShutdownHost_Dec_Holder" + + class ShutdownHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ShutdownHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ShutdownHostResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ShutdownHostResponse") + kw["aname"] = "_ShutdownHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ShutdownHostResponse_Holder" + self.pyclass = Holder + + class ShutdownHost_Task_Dec(ElementDeclaration): + literal = "ShutdownHost_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ShutdownHost_Task") + kw["aname"] = "_ShutdownHost_Task" + if ns0.ShutdownHostRequestType_Def not in ns0.ShutdownHost_Task_Dec.__bases__: + bases = list(ns0.ShutdownHost_Task_Dec.__bases__) + bases.insert(0, ns0.ShutdownHostRequestType_Def) + ns0.ShutdownHost_Task_Dec.__bases__ = tuple(bases) + + ns0.ShutdownHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ShutdownHost_Task_Dec_Holder" + + class ShutdownHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ShutdownHost_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ShutdownHost_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ShutdownHost_TaskResponse") + kw["aname"] = "_ShutdownHost_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ShutdownHost_TaskResponse_Holder" + self.pyclass = Holder + + class PowerDownHostToStandBy_Dec(ElementDeclaration): + literal = "PowerDownHostToStandBy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerDownHostToStandBy") + kw["aname"] = "_PowerDownHostToStandBy" + if ns0.PowerDownHostToStandByRequestType_Def not in ns0.PowerDownHostToStandBy_Dec.__bases__: + bases = list(ns0.PowerDownHostToStandBy_Dec.__bases__) + bases.insert(0, ns0.PowerDownHostToStandByRequestType_Def) + ns0.PowerDownHostToStandBy_Dec.__bases__ = tuple(bases) + + ns0.PowerDownHostToStandByRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerDownHostToStandBy_Dec_Holder" + + class PowerDownHostToStandByResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerDownHostToStandByResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerDownHostToStandByResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PowerDownHostToStandByResponse") + kw["aname"] = "_PowerDownHostToStandByResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PowerDownHostToStandByResponse_Holder" + self.pyclass = Holder + + class PowerDownHostToStandBy_Task_Dec(ElementDeclaration): + literal = "PowerDownHostToStandBy_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerDownHostToStandBy_Task") + kw["aname"] = "_PowerDownHostToStandBy_Task" + if ns0.PowerDownHostToStandByRequestType_Def not in ns0.PowerDownHostToStandBy_Task_Dec.__bases__: + bases = list(ns0.PowerDownHostToStandBy_Task_Dec.__bases__) + bases.insert(0, ns0.PowerDownHostToStandByRequestType_Def) + ns0.PowerDownHostToStandBy_Task_Dec.__bases__ = tuple(bases) + + ns0.PowerDownHostToStandByRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerDownHostToStandBy_Task_Dec_Holder" + + class PowerDownHostToStandBy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerDownHostToStandBy_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerDownHostToStandBy_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerDownHostToStandBy_TaskResponse") + kw["aname"] = "_PowerDownHostToStandBy_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerDownHostToStandBy_TaskResponse_Holder" + self.pyclass = Holder + + class PowerUpHostFromStandBy_Dec(ElementDeclaration): + literal = "PowerUpHostFromStandBy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerUpHostFromStandBy") + kw["aname"] = "_PowerUpHostFromStandBy" + if ns0.PowerUpHostFromStandByRequestType_Def not in ns0.PowerUpHostFromStandBy_Dec.__bases__: + bases = list(ns0.PowerUpHostFromStandBy_Dec.__bases__) + bases.insert(0, ns0.PowerUpHostFromStandByRequestType_Def) + ns0.PowerUpHostFromStandBy_Dec.__bases__ = tuple(bases) + + ns0.PowerUpHostFromStandByRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerUpHostFromStandBy_Dec_Holder" + + class PowerUpHostFromStandByResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerUpHostFromStandByResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerUpHostFromStandByResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PowerUpHostFromStandByResponse") + kw["aname"] = "_PowerUpHostFromStandByResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PowerUpHostFromStandByResponse_Holder" + self.pyclass = Holder + + class PowerUpHostFromStandBy_Task_Dec(ElementDeclaration): + literal = "PowerUpHostFromStandBy_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerUpHostFromStandBy_Task") + kw["aname"] = "_PowerUpHostFromStandBy_Task" + if ns0.PowerUpHostFromStandByRequestType_Def not in ns0.PowerUpHostFromStandBy_Task_Dec.__bases__: + bases = list(ns0.PowerUpHostFromStandBy_Task_Dec.__bases__) + bases.insert(0, ns0.PowerUpHostFromStandByRequestType_Def) + ns0.PowerUpHostFromStandBy_Task_Dec.__bases__ = tuple(bases) + + ns0.PowerUpHostFromStandByRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerUpHostFromStandBy_Task_Dec_Holder" + + class PowerUpHostFromStandBy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerUpHostFromStandBy_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerUpHostFromStandBy_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerUpHostFromStandBy_TaskResponse") + kw["aname"] = "_PowerUpHostFromStandBy_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerUpHostFromStandBy_TaskResponse_Holder" + self.pyclass = Holder + + class QueryMemoryOverhead_Dec(ElementDeclaration): + literal = "QueryMemoryOverhead" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryMemoryOverhead") + kw["aname"] = "_QueryMemoryOverhead" + if ns0.QueryMemoryOverheadRequestType_Def not in ns0.QueryMemoryOverhead_Dec.__bases__: + bases = list(ns0.QueryMemoryOverhead_Dec.__bases__) + bases.insert(0, ns0.QueryMemoryOverheadRequestType_Def) + ns0.QueryMemoryOverhead_Dec.__bases__ = tuple(bases) + + ns0.QueryMemoryOverheadRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryMemoryOverhead_Dec_Holder" + + class QueryMemoryOverheadResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryMemoryOverheadResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryMemoryOverheadResponse_Dec.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryMemoryOverheadResponse") + kw["aname"] = "_QueryMemoryOverheadResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryMemoryOverheadResponse_Holder" + self.pyclass = Holder + + class QueryMemoryOverheadEx_Dec(ElementDeclaration): + literal = "QueryMemoryOverheadEx" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryMemoryOverheadEx") + kw["aname"] = "_QueryMemoryOverheadEx" + if ns0.QueryMemoryOverheadExRequestType_Def not in ns0.QueryMemoryOverheadEx_Dec.__bases__: + bases = list(ns0.QueryMemoryOverheadEx_Dec.__bases__) + bases.insert(0, ns0.QueryMemoryOverheadExRequestType_Def) + ns0.QueryMemoryOverheadEx_Dec.__bases__ = tuple(bases) + + ns0.QueryMemoryOverheadExRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryMemoryOverheadEx_Dec_Holder" + + class QueryMemoryOverheadExResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryMemoryOverheadExResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryMemoryOverheadExResponse_Dec.schema + TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryMemoryOverheadExResponse") + kw["aname"] = "_QueryMemoryOverheadExResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryMemoryOverheadExResponse_Holder" + self.pyclass = Holder + + class ReconfigureHostForDAS_Dec(ElementDeclaration): + literal = "ReconfigureHostForDAS" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureHostForDAS") + kw["aname"] = "_ReconfigureHostForDAS" + if ns0.ReconfigureHostForDASRequestType_Def not in ns0.ReconfigureHostForDAS_Dec.__bases__: + bases = list(ns0.ReconfigureHostForDAS_Dec.__bases__) + bases.insert(0, ns0.ReconfigureHostForDASRequestType_Def) + ns0.ReconfigureHostForDAS_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureHostForDASRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureHostForDAS_Dec_Holder" + + class ReconfigureHostForDASResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureHostForDASResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureHostForDASResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureHostForDASResponse") + kw["aname"] = "_ReconfigureHostForDASResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureHostForDASResponse_Holder" + self.pyclass = Holder + + class ReconfigureHostForDAS_Task_Dec(ElementDeclaration): + literal = "ReconfigureHostForDAS_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureHostForDAS_Task") + kw["aname"] = "_ReconfigureHostForDAS_Task" + if ns0.ReconfigureHostForDASRequestType_Def not in ns0.ReconfigureHostForDAS_Task_Dec.__bases__: + bases = list(ns0.ReconfigureHostForDAS_Task_Dec.__bases__) + bases.insert(0, ns0.ReconfigureHostForDASRequestType_Def) + ns0.ReconfigureHostForDAS_Task_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureHostForDASRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureHostForDAS_Task_Dec_Holder" + + class ReconfigureHostForDAS_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureHostForDAS_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureHostForDAS_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReconfigureHostForDAS_TaskResponse") + kw["aname"] = "_ReconfigureHostForDAS_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ReconfigureHostForDAS_TaskResponse_Holder" + self.pyclass = Holder + + class UpdateFlags_Dec(ElementDeclaration): + literal = "UpdateFlags" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateFlags") + kw["aname"] = "_UpdateFlags" + if ns0.UpdateFlagsRequestType_Def not in ns0.UpdateFlags_Dec.__bases__: + bases = list(ns0.UpdateFlags_Dec.__bases__) + bases.insert(0, ns0.UpdateFlagsRequestType_Def) + ns0.UpdateFlags_Dec.__bases__ = tuple(bases) + + ns0.UpdateFlagsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateFlags_Dec_Holder" + + class UpdateFlagsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateFlagsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateFlagsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateFlagsResponse") + kw["aname"] = "_UpdateFlagsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateFlagsResponse_Holder" + self.pyclass = Holder + + class AcquireCimServicesTicket_Dec(ElementDeclaration): + literal = "AcquireCimServicesTicket" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AcquireCimServicesTicket") + kw["aname"] = "_AcquireCimServicesTicket" + if ns0.AcquireCimServicesTicketRequestType_Def not in ns0.AcquireCimServicesTicket_Dec.__bases__: + bases = list(ns0.AcquireCimServicesTicket_Dec.__bases__) + bases.insert(0, ns0.AcquireCimServicesTicketRequestType_Def) + ns0.AcquireCimServicesTicket_Dec.__bases__ = tuple(bases) + + ns0.AcquireCimServicesTicketRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AcquireCimServicesTicket_Dec_Holder" + + class AcquireCimServicesTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AcquireCimServicesTicketResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AcquireCimServicesTicketResponse_Dec.schema + TClist = [GTD("urn:vim25","HostServiceTicket",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AcquireCimServicesTicketResponse") + kw["aname"] = "_AcquireCimServicesTicketResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AcquireCimServicesTicketResponse_Holder" + self.pyclass = Holder + + class UpdateIpmi_Dec(ElementDeclaration): + literal = "UpdateIpmi" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateIpmi") + kw["aname"] = "_UpdateIpmi" + if ns0.UpdateIpmiRequestType_Def not in ns0.UpdateIpmi_Dec.__bases__: + bases = list(ns0.UpdateIpmi_Dec.__bases__) + bases.insert(0, ns0.UpdateIpmiRequestType_Def) + ns0.UpdateIpmi_Dec.__bases__ = tuple(bases) + + ns0.UpdateIpmiRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpmi_Dec_Holder" + + class UpdateIpmiResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateIpmiResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateIpmiResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateIpmiResponse") + kw["aname"] = "_UpdateIpmiResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateIpmiResponse_Holder" + self.pyclass = Holder + + class HttpNfcLeaseComplete_Dec(ElementDeclaration): + literal = "HttpNfcLeaseComplete" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HttpNfcLeaseComplete") + kw["aname"] = "_HttpNfcLeaseComplete" + if ns0.HttpNfcLeaseCompleteRequestType_Def not in ns0.HttpNfcLeaseComplete_Dec.__bases__: + bases = list(ns0.HttpNfcLeaseComplete_Dec.__bases__) + bases.insert(0, ns0.HttpNfcLeaseCompleteRequestType_Def) + ns0.HttpNfcLeaseComplete_Dec.__bases__ = tuple(bases) + + ns0.HttpNfcLeaseCompleteRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HttpNfcLeaseComplete_Dec_Holder" + + class HttpNfcLeaseCompleteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HttpNfcLeaseCompleteResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HttpNfcLeaseCompleteResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","HttpNfcLeaseCompleteResponse") + kw["aname"] = "_HttpNfcLeaseCompleteResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "HttpNfcLeaseCompleteResponse_Holder" + self.pyclass = Holder + + class HttpNfcLeaseAbort_Dec(ElementDeclaration): + literal = "HttpNfcLeaseAbort" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HttpNfcLeaseAbort") + kw["aname"] = "_HttpNfcLeaseAbort" + if ns0.HttpNfcLeaseAbortRequestType_Def not in ns0.HttpNfcLeaseAbort_Dec.__bases__: + bases = list(ns0.HttpNfcLeaseAbort_Dec.__bases__) + bases.insert(0, ns0.HttpNfcLeaseAbortRequestType_Def) + ns0.HttpNfcLeaseAbort_Dec.__bases__ = tuple(bases) + + ns0.HttpNfcLeaseAbortRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HttpNfcLeaseAbort_Dec_Holder" + + class HttpNfcLeaseAbortResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HttpNfcLeaseAbortResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HttpNfcLeaseAbortResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","HttpNfcLeaseAbortResponse") + kw["aname"] = "_HttpNfcLeaseAbortResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "HttpNfcLeaseAbortResponse_Holder" + self.pyclass = Holder + + class HttpNfcLeaseProgress_Dec(ElementDeclaration): + literal = "HttpNfcLeaseProgress" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HttpNfcLeaseProgress") + kw["aname"] = "_HttpNfcLeaseProgress" + if ns0.HttpNfcLeaseProgressRequestType_Def not in ns0.HttpNfcLeaseProgress_Dec.__bases__: + bases = list(ns0.HttpNfcLeaseProgress_Dec.__bases__) + bases.insert(0, ns0.HttpNfcLeaseProgressRequestType_Def) + ns0.HttpNfcLeaseProgress_Dec.__bases__ = tuple(bases) + + ns0.HttpNfcLeaseProgressRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HttpNfcLeaseProgress_Dec_Holder" + + class HttpNfcLeaseProgressResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HttpNfcLeaseProgressResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HttpNfcLeaseProgressResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","HttpNfcLeaseProgressResponse") + kw["aname"] = "_HttpNfcLeaseProgressResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "HttpNfcLeaseProgressResponse_Holder" + self.pyclass = Holder + + class QueryIpPools_Dec(ElementDeclaration): + literal = "QueryIpPools" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryIpPools") + kw["aname"] = "_QueryIpPools" + if ns0.QueryIpPoolsRequestType_Def not in ns0.QueryIpPools_Dec.__bases__: + bases = list(ns0.QueryIpPools_Dec.__bases__) + bases.insert(0, ns0.QueryIpPoolsRequestType_Def) + ns0.QueryIpPools_Dec.__bases__ = tuple(bases) + + ns0.QueryIpPoolsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryIpPools_Dec_Holder" + + class QueryIpPoolsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryIpPoolsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryIpPoolsResponse_Dec.schema + TClist = [GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryIpPoolsResponse") + kw["aname"] = "_QueryIpPoolsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryIpPoolsResponse_Holder" + self.pyclass = Holder + + class CreateIpPool_Dec(ElementDeclaration): + literal = "CreateIpPool" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateIpPool") + kw["aname"] = "_CreateIpPool" + if ns0.CreateIpPoolRequestType_Def not in ns0.CreateIpPool_Dec.__bases__: + bases = list(ns0.CreateIpPool_Dec.__bases__) + bases.insert(0, ns0.CreateIpPoolRequestType_Def) + ns0.CreateIpPool_Dec.__bases__ = tuple(bases) + + ns0.CreateIpPoolRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateIpPool_Dec_Holder" + + class CreateIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateIpPoolResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateIpPoolResponse_Dec.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateIpPoolResponse") + kw["aname"] = "_CreateIpPoolResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateIpPoolResponse_Holder" + self.pyclass = Holder + + class UpdateIpPool_Dec(ElementDeclaration): + literal = "UpdateIpPool" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateIpPool") + kw["aname"] = "_UpdateIpPool" + if ns0.UpdateIpPoolRequestType_Def not in ns0.UpdateIpPool_Dec.__bases__: + bases = list(ns0.UpdateIpPool_Dec.__bases__) + bases.insert(0, ns0.UpdateIpPoolRequestType_Def) + ns0.UpdateIpPool_Dec.__bases__ = tuple(bases) + + ns0.UpdateIpPoolRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpPool_Dec_Holder" + + class UpdateIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateIpPoolResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateIpPoolResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateIpPoolResponse") + kw["aname"] = "_UpdateIpPoolResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateIpPoolResponse_Holder" + self.pyclass = Holder + + class DestroyIpPool_Dec(ElementDeclaration): + literal = "DestroyIpPool" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestroyIpPool") + kw["aname"] = "_DestroyIpPool" + if ns0.DestroyIpPoolRequestType_Def not in ns0.DestroyIpPool_Dec.__bases__: + bases = list(ns0.DestroyIpPool_Dec.__bases__) + bases.insert(0, ns0.DestroyIpPoolRequestType_Def) + ns0.DestroyIpPool_Dec.__bases__ = tuple(bases) + + ns0.DestroyIpPoolRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestroyIpPool_Dec_Holder" + + class DestroyIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyIpPoolResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyIpPoolResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyIpPoolResponse") + kw["aname"] = "_DestroyIpPoolResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyIpPoolResponse_Holder" + self.pyclass = Holder + + class AssociateIpPool_Dec(ElementDeclaration): + literal = "AssociateIpPool" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AssociateIpPool") + kw["aname"] = "_AssociateIpPool" + if ns0.AssociateIpPoolRequestType_Def not in ns0.AssociateIpPool_Dec.__bases__: + bases = list(ns0.AssociateIpPool_Dec.__bases__) + bases.insert(0, ns0.AssociateIpPoolRequestType_Def) + ns0.AssociateIpPool_Dec.__bases__ = tuple(bases) + + ns0.AssociateIpPoolRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AssociateIpPool_Dec_Holder" + + class AssociateIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AssociateIpPoolResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AssociateIpPoolResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AssociateIpPoolResponse") + kw["aname"] = "_AssociateIpPoolResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AssociateIpPoolResponse_Holder" + self.pyclass = Holder + + class UpdateAssignedLicense_Dec(ElementDeclaration): + literal = "UpdateAssignedLicense" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateAssignedLicense") + kw["aname"] = "_UpdateAssignedLicense" + if ns0.UpdateAssignedLicenseRequestType_Def not in ns0.UpdateAssignedLicense_Dec.__bases__: + bases = list(ns0.UpdateAssignedLicense_Dec.__bases__) + bases.insert(0, ns0.UpdateAssignedLicenseRequestType_Def) + ns0.UpdateAssignedLicense_Dec.__bases__ = tuple(bases) + + ns0.UpdateAssignedLicenseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateAssignedLicense_Dec_Holder" + + class UpdateAssignedLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateAssignedLicenseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateAssignedLicenseResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UpdateAssignedLicenseResponse") + kw["aname"] = "_UpdateAssignedLicenseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UpdateAssignedLicenseResponse_Holder" + self.pyclass = Holder + + class RemoveAssignedLicense_Dec(ElementDeclaration): + literal = "RemoveAssignedLicense" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveAssignedLicense") + kw["aname"] = "_RemoveAssignedLicense" + if ns0.RemoveAssignedLicenseRequestType_Def not in ns0.RemoveAssignedLicense_Dec.__bases__: + bases = list(ns0.RemoveAssignedLicense_Dec.__bases__) + bases.insert(0, ns0.RemoveAssignedLicenseRequestType_Def) + ns0.RemoveAssignedLicense_Dec.__bases__ = tuple(bases) + + ns0.RemoveAssignedLicenseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveAssignedLicense_Dec_Holder" + + class RemoveAssignedLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveAssignedLicenseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveAssignedLicenseResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveAssignedLicenseResponse") + kw["aname"] = "_RemoveAssignedLicenseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveAssignedLicenseResponse_Holder" + self.pyclass = Holder + + class QueryAssignedLicenses_Dec(ElementDeclaration): + literal = "QueryAssignedLicenses" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryAssignedLicenses") + kw["aname"] = "_QueryAssignedLicenses" + if ns0.QueryAssignedLicensesRequestType_Def not in ns0.QueryAssignedLicenses_Dec.__bases__: + bases = list(ns0.QueryAssignedLicenses_Dec.__bases__) + bases.insert(0, ns0.QueryAssignedLicensesRequestType_Def) + ns0.QueryAssignedLicenses_Dec.__bases__ = tuple(bases) + + ns0.QueryAssignedLicensesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryAssignedLicenses_Dec_Holder" + + class QueryAssignedLicensesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryAssignedLicensesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryAssignedLicensesResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseAssignmentManagerLicenseAssignment",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryAssignedLicensesResponse") + kw["aname"] = "_QueryAssignedLicensesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryAssignedLicensesResponse_Holder" + self.pyclass = Holder + + class IsFeatureAvailable_Dec(ElementDeclaration): + literal = "IsFeatureAvailable" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IsFeatureAvailable") + kw["aname"] = "_IsFeatureAvailable" + if ns0.IsFeatureAvailableRequestType_Def not in ns0.IsFeatureAvailable_Dec.__bases__: + bases = list(ns0.IsFeatureAvailable_Dec.__bases__) + bases.insert(0, ns0.IsFeatureAvailableRequestType_Def) + ns0.IsFeatureAvailable_Dec.__bases__ = tuple(bases) + + ns0.IsFeatureAvailableRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IsFeatureAvailable_Dec_Holder" + + class IsFeatureAvailableResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "IsFeatureAvailableResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.IsFeatureAvailableResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseAssignmentManagerFeatureLicenseAvailability",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","IsFeatureAvailableResponse") + kw["aname"] = "_IsFeatureAvailableResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "IsFeatureAvailableResponse_Holder" + self.pyclass = Holder + + class SetFeatureInUse_Dec(ElementDeclaration): + literal = "SetFeatureInUse" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetFeatureInUse") + kw["aname"] = "_SetFeatureInUse" + if ns0.SetFeatureInUseRequestType_Def not in ns0.SetFeatureInUse_Dec.__bases__: + bases = list(ns0.SetFeatureInUse_Dec.__bases__) + bases.insert(0, ns0.SetFeatureInUseRequestType_Def) + ns0.SetFeatureInUse_Dec.__bases__ = tuple(bases) + + ns0.SetFeatureInUseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetFeatureInUse_Dec_Holder" + + class SetFeatureInUseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetFeatureInUseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetFeatureInUseResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetFeatureInUseResponse") + kw["aname"] = "_SetFeatureInUseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetFeatureInUseResponse_Holder" + self.pyclass = Holder + + class ResetFeatureInUse_Dec(ElementDeclaration): + literal = "ResetFeatureInUse" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetFeatureInUse") + kw["aname"] = "_ResetFeatureInUse" + if ns0.ResetFeatureInUseRequestType_Def not in ns0.ResetFeatureInUse_Dec.__bases__: + bases = list(ns0.ResetFeatureInUse_Dec.__bases__) + bases.insert(0, ns0.ResetFeatureInUseRequestType_Def) + ns0.ResetFeatureInUse_Dec.__bases__ = tuple(bases) + + ns0.ResetFeatureInUseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetFeatureInUse_Dec_Holder" + + class ResetFeatureInUseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetFeatureInUseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetFeatureInUseResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetFeatureInUseResponse") + kw["aname"] = "_ResetFeatureInUseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetFeatureInUseResponse_Holder" + self.pyclass = Holder + + class QuerySupportedFeatures_Dec(ElementDeclaration): + literal = "QuerySupportedFeatures" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QuerySupportedFeatures") + kw["aname"] = "_QuerySupportedFeatures" + if ns0.QuerySupportedFeaturesRequestType_Def not in ns0.QuerySupportedFeatures_Dec.__bases__: + bases = list(ns0.QuerySupportedFeatures_Dec.__bases__) + bases.insert(0, ns0.QuerySupportedFeaturesRequestType_Def) + ns0.QuerySupportedFeatures_Dec.__bases__ = tuple(bases) + + ns0.QuerySupportedFeaturesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QuerySupportedFeatures_Dec_Holder" + + class QuerySupportedFeaturesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QuerySupportedFeaturesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QuerySupportedFeaturesResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QuerySupportedFeaturesResponse") + kw["aname"] = "_QuerySupportedFeaturesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QuerySupportedFeaturesResponse_Holder" + self.pyclass = Holder + + class QueryLicenseSourceAvailability_Dec(ElementDeclaration): + literal = "QueryLicenseSourceAvailability" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryLicenseSourceAvailability") + kw["aname"] = "_QueryLicenseSourceAvailability" + if ns0.QueryLicenseSourceAvailabilityRequestType_Def not in ns0.QueryLicenseSourceAvailability_Dec.__bases__: + bases = list(ns0.QueryLicenseSourceAvailability_Dec.__bases__) + bases.insert(0, ns0.QueryLicenseSourceAvailabilityRequestType_Def) + ns0.QueryLicenseSourceAvailability_Dec.__bases__ = tuple(bases) + + ns0.QueryLicenseSourceAvailabilityRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryLicenseSourceAvailability_Dec_Holder" + + class QueryLicenseSourceAvailabilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryLicenseSourceAvailabilityResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryLicenseSourceAvailabilityResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseAvailabilityInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryLicenseSourceAvailabilityResponse") + kw["aname"] = "_QueryLicenseSourceAvailabilityResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryLicenseSourceAvailabilityResponse_Holder" + self.pyclass = Holder + + class QueryLicenseUsage_Dec(ElementDeclaration): + literal = "QueryLicenseUsage" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryLicenseUsage") + kw["aname"] = "_QueryLicenseUsage" + if ns0.QueryLicenseUsageRequestType_Def not in ns0.QueryLicenseUsage_Dec.__bases__: + bases = list(ns0.QueryLicenseUsage_Dec.__bases__) + bases.insert(0, ns0.QueryLicenseUsageRequestType_Def) + ns0.QueryLicenseUsage_Dec.__bases__ = tuple(bases) + + ns0.QueryLicenseUsageRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryLicenseUsage_Dec_Holder" + + class QueryLicenseUsageResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryLicenseUsageResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryLicenseUsageResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseUsageInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryLicenseUsageResponse") + kw["aname"] = "_QueryLicenseUsageResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryLicenseUsageResponse_Holder" + self.pyclass = Holder + + class SetLicenseEdition_Dec(ElementDeclaration): + literal = "SetLicenseEdition" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetLicenseEdition") + kw["aname"] = "_SetLicenseEdition" + if ns0.SetLicenseEditionRequestType_Def not in ns0.SetLicenseEdition_Dec.__bases__: + bases = list(ns0.SetLicenseEdition_Dec.__bases__) + bases.insert(0, ns0.SetLicenseEditionRequestType_Def) + ns0.SetLicenseEdition_Dec.__bases__ = tuple(bases) + + ns0.SetLicenseEditionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetLicenseEdition_Dec_Holder" + + class SetLicenseEditionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetLicenseEditionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetLicenseEditionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetLicenseEditionResponse") + kw["aname"] = "_SetLicenseEditionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetLicenseEditionResponse_Holder" + self.pyclass = Holder + + class CheckLicenseFeature_Dec(ElementDeclaration): + literal = "CheckLicenseFeature" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckLicenseFeature") + kw["aname"] = "_CheckLicenseFeature" + if ns0.CheckLicenseFeatureRequestType_Def not in ns0.CheckLicenseFeature_Dec.__bases__: + bases = list(ns0.CheckLicenseFeature_Dec.__bases__) + bases.insert(0, ns0.CheckLicenseFeatureRequestType_Def) + ns0.CheckLicenseFeature_Dec.__bases__ = tuple(bases) + + ns0.CheckLicenseFeatureRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckLicenseFeature_Dec_Holder" + + class CheckLicenseFeatureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckLicenseFeatureResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckLicenseFeatureResponse_Dec.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckLicenseFeatureResponse") + kw["aname"] = "_CheckLicenseFeatureResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CheckLicenseFeatureResponse_Holder" + self.pyclass = Holder + + class EnableFeature_Dec(ElementDeclaration): + literal = "EnableFeature" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnableFeature") + kw["aname"] = "_EnableFeature" + if ns0.EnableFeatureRequestType_Def not in ns0.EnableFeature_Dec.__bases__: + bases = list(ns0.EnableFeature_Dec.__bases__) + bases.insert(0, ns0.EnableFeatureRequestType_Def) + ns0.EnableFeature_Dec.__bases__ = tuple(bases) + + ns0.EnableFeatureRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnableFeature_Dec_Holder" + + class EnableFeatureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnableFeatureResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnableFeatureResponse_Dec.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","EnableFeatureResponse") + kw["aname"] = "_EnableFeatureResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "EnableFeatureResponse_Holder" + self.pyclass = Holder + + class DisableFeature_Dec(ElementDeclaration): + literal = "DisableFeature" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisableFeature") + kw["aname"] = "_DisableFeature" + if ns0.DisableFeatureRequestType_Def not in ns0.DisableFeature_Dec.__bases__: + bases = list(ns0.DisableFeature_Dec.__bases__) + bases.insert(0, ns0.DisableFeatureRequestType_Def) + ns0.DisableFeature_Dec.__bases__ = tuple(bases) + + ns0.DisableFeatureRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisableFeature_Dec_Holder" + + class DisableFeatureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisableFeatureResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisableFeatureResponse_Dec.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DisableFeatureResponse") + kw["aname"] = "_DisableFeatureResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DisableFeatureResponse_Holder" + self.pyclass = Holder + + class ConfigureLicenseSource_Dec(ElementDeclaration): + literal = "ConfigureLicenseSource" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ConfigureLicenseSource") + kw["aname"] = "_ConfigureLicenseSource" + if ns0.ConfigureLicenseSourceRequestType_Def not in ns0.ConfigureLicenseSource_Dec.__bases__: + bases = list(ns0.ConfigureLicenseSource_Dec.__bases__) + bases.insert(0, ns0.ConfigureLicenseSourceRequestType_Def) + ns0.ConfigureLicenseSource_Dec.__bases__ = tuple(bases) + + ns0.ConfigureLicenseSourceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ConfigureLicenseSource_Dec_Holder" + + class ConfigureLicenseSourceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ConfigureLicenseSourceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ConfigureLicenseSourceResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ConfigureLicenseSourceResponse") + kw["aname"] = "_ConfigureLicenseSourceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ConfigureLicenseSourceResponse_Holder" + self.pyclass = Holder + + class UpdateLicense_Dec(ElementDeclaration): + literal = "UpdateLicense" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateLicense") + kw["aname"] = "_UpdateLicense" + if ns0.UpdateLicenseRequestType_Def not in ns0.UpdateLicense_Dec.__bases__: + bases = list(ns0.UpdateLicense_Dec.__bases__) + bases.insert(0, ns0.UpdateLicenseRequestType_Def) + ns0.UpdateLicense_Dec.__bases__ = tuple(bases) + + ns0.UpdateLicenseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateLicense_Dec_Holder" + + class UpdateLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateLicenseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateLicenseResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UpdateLicenseResponse") + kw["aname"] = "_UpdateLicenseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UpdateLicenseResponse_Holder" + self.pyclass = Holder + + class AddLicense_Dec(ElementDeclaration): + literal = "AddLicense" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddLicense") + kw["aname"] = "_AddLicense" + if ns0.AddLicenseRequestType_Def not in ns0.AddLicense_Dec.__bases__: + bases = list(ns0.AddLicense_Dec.__bases__) + bases.insert(0, ns0.AddLicenseRequestType_Def) + ns0.AddLicense_Dec.__bases__ = tuple(bases) + + ns0.AddLicenseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddLicense_Dec_Holder" + + class AddLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddLicenseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddLicenseResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddLicenseResponse") + kw["aname"] = "_AddLicenseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddLicenseResponse_Holder" + self.pyclass = Holder + + class RemoveLicense_Dec(ElementDeclaration): + literal = "RemoveLicense" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveLicense") + kw["aname"] = "_RemoveLicense" + if ns0.RemoveLicenseRequestType_Def not in ns0.RemoveLicense_Dec.__bases__: + bases = list(ns0.RemoveLicense_Dec.__bases__) + bases.insert(0, ns0.RemoveLicenseRequestType_Def) + ns0.RemoveLicense_Dec.__bases__ = tuple(bases) + + ns0.RemoveLicenseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveLicense_Dec_Holder" + + class RemoveLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveLicenseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveLicenseResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveLicenseResponse") + kw["aname"] = "_RemoveLicenseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveLicenseResponse_Holder" + self.pyclass = Holder + + class DecodeLicense_Dec(ElementDeclaration): + literal = "DecodeLicense" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DecodeLicense") + kw["aname"] = "_DecodeLicense" + if ns0.DecodeLicenseRequestType_Def not in ns0.DecodeLicense_Dec.__bases__: + bases = list(ns0.DecodeLicense_Dec.__bases__) + bases.insert(0, ns0.DecodeLicenseRequestType_Def) + ns0.DecodeLicense_Dec.__bases__ = tuple(bases) + + ns0.DecodeLicenseRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DecodeLicense_Dec_Holder" + + class DecodeLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DecodeLicenseResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DecodeLicenseResponse_Dec.schema + TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DecodeLicenseResponse") + kw["aname"] = "_DecodeLicenseResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DecodeLicenseResponse_Holder" + self.pyclass = Holder + + class UpdateLicenseLabel_Dec(ElementDeclaration): + literal = "UpdateLicenseLabel" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateLicenseLabel") + kw["aname"] = "_UpdateLicenseLabel" + if ns0.UpdateLicenseLabelRequestType_Def not in ns0.UpdateLicenseLabel_Dec.__bases__: + bases = list(ns0.UpdateLicenseLabel_Dec.__bases__) + bases.insert(0, ns0.UpdateLicenseLabelRequestType_Def) + ns0.UpdateLicenseLabel_Dec.__bases__ = tuple(bases) + + ns0.UpdateLicenseLabelRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateLicenseLabel_Dec_Holder" + + class UpdateLicenseLabelResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateLicenseLabelResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateLicenseLabelResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateLicenseLabelResponse") + kw["aname"] = "_UpdateLicenseLabelResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateLicenseLabelResponse_Holder" + self.pyclass = Holder + + class RemoveLicenseLabel_Dec(ElementDeclaration): + literal = "RemoveLicenseLabel" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveLicenseLabel") + kw["aname"] = "_RemoveLicenseLabel" + if ns0.RemoveLicenseLabelRequestType_Def not in ns0.RemoveLicenseLabel_Dec.__bases__: + bases = list(ns0.RemoveLicenseLabel_Dec.__bases__) + bases.insert(0, ns0.RemoveLicenseLabelRequestType_Def) + ns0.RemoveLicenseLabel_Dec.__bases__ = tuple(bases) + + ns0.RemoveLicenseLabelRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveLicenseLabel_Dec_Holder" + + class RemoveLicenseLabelResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveLicenseLabelResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveLicenseLabelResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveLicenseLabelResponse") + kw["aname"] = "_RemoveLicenseLabelResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveLicenseLabelResponse_Holder" + self.pyclass = Holder + + class Reload_Dec(ElementDeclaration): + literal = "Reload" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Reload") + kw["aname"] = "_Reload" + if ns0.ReloadRequestType_Def not in ns0.Reload_Dec.__bases__: + bases = list(ns0.Reload_Dec.__bases__) + bases.insert(0, ns0.ReloadRequestType_Def) + ns0.Reload_Dec.__bases__ = tuple(bases) + + ns0.ReloadRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Reload_Dec_Holder" + + class ReloadResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReloadResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReloadResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReloadResponse") + kw["aname"] = "_ReloadResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReloadResponse_Holder" + self.pyclass = Holder + + class Rename_Dec(ElementDeclaration): + literal = "Rename" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Rename") + kw["aname"] = "_Rename" + if ns0.RenameRequestType_Def not in ns0.Rename_Dec.__bases__: + bases = list(ns0.Rename_Dec.__bases__) + bases.insert(0, ns0.RenameRequestType_Def) + ns0.Rename_Dec.__bases__ = tuple(bases) + + ns0.RenameRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Rename_Dec_Holder" + + class RenameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RenameResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RenameResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RenameResponse") + kw["aname"] = "_RenameResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RenameResponse_Holder" + self.pyclass = Holder + + class Rename_Task_Dec(ElementDeclaration): + literal = "Rename_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Rename_Task") + kw["aname"] = "_Rename_Task" + if ns0.RenameRequestType_Def not in ns0.Rename_Task_Dec.__bases__: + bases = list(ns0.Rename_Task_Dec.__bases__) + bases.insert(0, ns0.RenameRequestType_Def) + ns0.Rename_Task_Dec.__bases__ = tuple(bases) + + ns0.RenameRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Rename_Task_Dec_Holder" + + class Rename_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "Rename_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.Rename_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","Rename_TaskResponse") + kw["aname"] = "_Rename_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "Rename_TaskResponse_Holder" + self.pyclass = Holder + + class Destroy_Dec(ElementDeclaration): + literal = "Destroy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Destroy") + kw["aname"] = "_Destroy" + if ns0.DestroyRequestType_Def not in ns0.Destroy_Dec.__bases__: + bases = list(ns0.Destroy_Dec.__bases__) + bases.insert(0, ns0.DestroyRequestType_Def) + ns0.Destroy_Dec.__bases__ = tuple(bases) + + ns0.DestroyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Destroy_Dec_Holder" + + class DestroyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyResponse") + kw["aname"] = "_DestroyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyResponse_Holder" + self.pyclass = Holder + + class Destroy_Task_Dec(ElementDeclaration): + literal = "Destroy_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Destroy_Task") + kw["aname"] = "_Destroy_Task" + if ns0.DestroyRequestType_Def not in ns0.Destroy_Task_Dec.__bases__: + bases = list(ns0.Destroy_Task_Dec.__bases__) + bases.insert(0, ns0.DestroyRequestType_Def) + ns0.Destroy_Task_Dec.__bases__ = tuple(bases) + + ns0.DestroyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Destroy_Task_Dec_Holder" + + class Destroy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "Destroy_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.Destroy_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","Destroy_TaskResponse") + kw["aname"] = "_Destroy_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "Destroy_TaskResponse_Holder" + self.pyclass = Holder + + class DestroyNetwork_Dec(ElementDeclaration): + literal = "DestroyNetwork" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestroyNetwork") + kw["aname"] = "_DestroyNetwork" + if ns0.DestroyNetworkRequestType_Def not in ns0.DestroyNetwork_Dec.__bases__: + bases = list(ns0.DestroyNetwork_Dec.__bases__) + bases.insert(0, ns0.DestroyNetworkRequestType_Def) + ns0.DestroyNetwork_Dec.__bases__ = tuple(bases) + + ns0.DestroyNetworkRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestroyNetwork_Dec_Holder" + + class DestroyNetworkResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyNetworkResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyNetworkResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyNetworkResponse") + kw["aname"] = "_DestroyNetworkResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyNetworkResponse_Holder" + self.pyclass = Holder + + class ValidateHost_Dec(ElementDeclaration): + literal = "ValidateHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ValidateHost") + kw["aname"] = "_ValidateHost" + if ns0.ValidateHostRequestType_Def not in ns0.ValidateHost_Dec.__bases__: + bases = list(ns0.ValidateHost_Dec.__bases__) + bases.insert(0, ns0.ValidateHostRequestType_Def) + ns0.ValidateHost_Dec.__bases__ = tuple(bases) + + ns0.ValidateHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ValidateHost_Dec_Holder" + + class ValidateHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ValidateHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ValidateHostResponse_Dec.schema + TClist = [GTD("urn:vim25","OvfValidateHostResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ValidateHostResponse") + kw["aname"] = "_ValidateHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ValidateHostResponse_Holder" + self.pyclass = Holder + + class ParseDescriptor_Dec(ElementDeclaration): + literal = "ParseDescriptor" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ParseDescriptor") + kw["aname"] = "_ParseDescriptor" + if ns0.ParseDescriptorRequestType_Def not in ns0.ParseDescriptor_Dec.__bases__: + bases = list(ns0.ParseDescriptor_Dec.__bases__) + bases.insert(0, ns0.ParseDescriptorRequestType_Def) + ns0.ParseDescriptor_Dec.__bases__ = tuple(bases) + + ns0.ParseDescriptorRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ParseDescriptor_Dec_Holder" + + class ParseDescriptorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ParseDescriptorResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ParseDescriptorResponse_Dec.schema + TClist = [GTD("urn:vim25","OvfParseDescriptorResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ParseDescriptorResponse") + kw["aname"] = "_ParseDescriptorResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ParseDescriptorResponse_Holder" + self.pyclass = Holder + + class CreateImportSpec_Dec(ElementDeclaration): + literal = "CreateImportSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateImportSpec") + kw["aname"] = "_CreateImportSpec" + if ns0.CreateImportSpecRequestType_Def not in ns0.CreateImportSpec_Dec.__bases__: + bases = list(ns0.CreateImportSpec_Dec.__bases__) + bases.insert(0, ns0.CreateImportSpecRequestType_Def) + ns0.CreateImportSpec_Dec.__bases__ = tuple(bases) + + ns0.CreateImportSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateImportSpec_Dec_Holder" + + class CreateImportSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateImportSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateImportSpecResponse_Dec.schema + TClist = [GTD("urn:vim25","OvfCreateImportSpecResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateImportSpecResponse") + kw["aname"] = "_CreateImportSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateImportSpecResponse_Holder" + self.pyclass = Holder + + class CreateDescriptor_Dec(ElementDeclaration): + literal = "CreateDescriptor" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateDescriptor") + kw["aname"] = "_CreateDescriptor" + if ns0.CreateDescriptorRequestType_Def not in ns0.CreateDescriptor_Dec.__bases__: + bases = list(ns0.CreateDescriptor_Dec.__bases__) + bases.insert(0, ns0.CreateDescriptorRequestType_Def) + ns0.CreateDescriptor_Dec.__bases__ = tuple(bases) + + ns0.CreateDescriptorRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateDescriptor_Dec_Holder" + + class CreateDescriptorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateDescriptorResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateDescriptorResponse_Dec.schema + TClist = [GTD("urn:vim25","OvfCreateDescriptorResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateDescriptorResponse") + kw["aname"] = "_CreateDescriptorResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateDescriptorResponse_Holder" + self.pyclass = Holder + + class QueryPerfProviderSummary_Dec(ElementDeclaration): + literal = "QueryPerfProviderSummary" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPerfProviderSummary") + kw["aname"] = "_QueryPerfProviderSummary" + if ns0.QueryPerfProviderSummaryRequestType_Def not in ns0.QueryPerfProviderSummary_Dec.__bases__: + bases = list(ns0.QueryPerfProviderSummary_Dec.__bases__) + bases.insert(0, ns0.QueryPerfProviderSummaryRequestType_Def) + ns0.QueryPerfProviderSummary_Dec.__bases__ = tuple(bases) + + ns0.QueryPerfProviderSummaryRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfProviderSummary_Dec_Holder" + + class QueryPerfProviderSummaryResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPerfProviderSummaryResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPerfProviderSummaryResponse_Dec.schema + TClist = [GTD("urn:vim25","PerfProviderSummary",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPerfProviderSummaryResponse") + kw["aname"] = "_QueryPerfProviderSummaryResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryPerfProviderSummaryResponse_Holder" + self.pyclass = Holder + + class QueryAvailablePerfMetric_Dec(ElementDeclaration): + literal = "QueryAvailablePerfMetric" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryAvailablePerfMetric") + kw["aname"] = "_QueryAvailablePerfMetric" + if ns0.QueryAvailablePerfMetricRequestType_Def not in ns0.QueryAvailablePerfMetric_Dec.__bases__: + bases = list(ns0.QueryAvailablePerfMetric_Dec.__bases__) + bases.insert(0, ns0.QueryAvailablePerfMetricRequestType_Def) + ns0.QueryAvailablePerfMetric_Dec.__bases__ = tuple(bases) + + ns0.QueryAvailablePerfMetricRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailablePerfMetric_Dec_Holder" + + class QueryAvailablePerfMetricResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryAvailablePerfMetricResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryAvailablePerfMetricResponse_Dec.schema + TClist = [GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryAvailablePerfMetricResponse") + kw["aname"] = "_QueryAvailablePerfMetricResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryAvailablePerfMetricResponse_Holder" + self.pyclass = Holder + + class QueryPerfCounter_Dec(ElementDeclaration): + literal = "QueryPerfCounter" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPerfCounter") + kw["aname"] = "_QueryPerfCounter" + if ns0.QueryPerfCounterRequestType_Def not in ns0.QueryPerfCounter_Dec.__bases__: + bases = list(ns0.QueryPerfCounter_Dec.__bases__) + bases.insert(0, ns0.QueryPerfCounterRequestType_Def) + ns0.QueryPerfCounter_Dec.__bases__ = tuple(bases) + + ns0.QueryPerfCounterRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfCounter_Dec_Holder" + + class QueryPerfCounterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPerfCounterResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPerfCounterResponse_Dec.schema + TClist = [GTD("urn:vim25","PerfCounterInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPerfCounterResponse") + kw["aname"] = "_QueryPerfCounterResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryPerfCounterResponse_Holder" + self.pyclass = Holder + + class QueryPerfCounterByLevel_Dec(ElementDeclaration): + literal = "QueryPerfCounterByLevel" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPerfCounterByLevel") + kw["aname"] = "_QueryPerfCounterByLevel" + if ns0.QueryPerfCounterByLevelRequestType_Def not in ns0.QueryPerfCounterByLevel_Dec.__bases__: + bases = list(ns0.QueryPerfCounterByLevel_Dec.__bases__) + bases.insert(0, ns0.QueryPerfCounterByLevelRequestType_Def) + ns0.QueryPerfCounterByLevel_Dec.__bases__ = tuple(bases) + + ns0.QueryPerfCounterByLevelRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfCounterByLevel_Dec_Holder" + + class QueryPerfCounterByLevelResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPerfCounterByLevelResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPerfCounterByLevelResponse_Dec.schema + TClist = [GTD("urn:vim25","PerfCounterInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPerfCounterByLevelResponse") + kw["aname"] = "_QueryPerfCounterByLevelResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryPerfCounterByLevelResponse_Holder" + self.pyclass = Holder + + class QueryPerf_Dec(ElementDeclaration): + literal = "QueryPerf" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPerf") + kw["aname"] = "_QueryPerf" + if ns0.QueryPerfRequestType_Def not in ns0.QueryPerf_Dec.__bases__: + bases = list(ns0.QueryPerf_Dec.__bases__) + bases.insert(0, ns0.QueryPerfRequestType_Def) + ns0.QueryPerf_Dec.__bases__ = tuple(bases) + + ns0.QueryPerfRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPerf_Dec_Holder" + + class QueryPerfResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPerfResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPerfResponse_Dec.schema + TClist = [GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPerfResponse") + kw["aname"] = "_QueryPerfResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryPerfResponse_Holder" + self.pyclass = Holder + + class QueryPerfComposite_Dec(ElementDeclaration): + literal = "QueryPerfComposite" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPerfComposite") + kw["aname"] = "_QueryPerfComposite" + if ns0.QueryPerfCompositeRequestType_Def not in ns0.QueryPerfComposite_Dec.__bases__: + bases = list(ns0.QueryPerfComposite_Dec.__bases__) + bases.insert(0, ns0.QueryPerfCompositeRequestType_Def) + ns0.QueryPerfComposite_Dec.__bases__ = tuple(bases) + + ns0.QueryPerfCompositeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfComposite_Dec_Holder" + + class QueryPerfCompositeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPerfCompositeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPerfCompositeResponse_Dec.schema + TClist = [GTD("urn:vim25","PerfCompositeMetric",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPerfCompositeResponse") + kw["aname"] = "_QueryPerfCompositeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryPerfCompositeResponse_Holder" + self.pyclass = Holder + + class CreatePerfInterval_Dec(ElementDeclaration): + literal = "CreatePerfInterval" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreatePerfInterval") + kw["aname"] = "_CreatePerfInterval" + if ns0.CreatePerfIntervalRequestType_Def not in ns0.CreatePerfInterval_Dec.__bases__: + bases = list(ns0.CreatePerfInterval_Dec.__bases__) + bases.insert(0, ns0.CreatePerfIntervalRequestType_Def) + ns0.CreatePerfInterval_Dec.__bases__ = tuple(bases) + + ns0.CreatePerfIntervalRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreatePerfInterval_Dec_Holder" + + class CreatePerfIntervalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreatePerfIntervalResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreatePerfIntervalResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CreatePerfIntervalResponse") + kw["aname"] = "_CreatePerfIntervalResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CreatePerfIntervalResponse_Holder" + self.pyclass = Holder + + class RemovePerfInterval_Dec(ElementDeclaration): + literal = "RemovePerfInterval" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemovePerfInterval") + kw["aname"] = "_RemovePerfInterval" + if ns0.RemovePerfIntervalRequestType_Def not in ns0.RemovePerfInterval_Dec.__bases__: + bases = list(ns0.RemovePerfInterval_Dec.__bases__) + bases.insert(0, ns0.RemovePerfIntervalRequestType_Def) + ns0.RemovePerfInterval_Dec.__bases__ = tuple(bases) + + ns0.RemovePerfIntervalRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemovePerfInterval_Dec_Holder" + + class RemovePerfIntervalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemovePerfIntervalResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemovePerfIntervalResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemovePerfIntervalResponse") + kw["aname"] = "_RemovePerfIntervalResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemovePerfIntervalResponse_Holder" + self.pyclass = Holder + + class UpdatePerfInterval_Dec(ElementDeclaration): + literal = "UpdatePerfInterval" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdatePerfInterval") + kw["aname"] = "_UpdatePerfInterval" + if ns0.UpdatePerfIntervalRequestType_Def not in ns0.UpdatePerfInterval_Dec.__bases__: + bases = list(ns0.UpdatePerfInterval_Dec.__bases__) + bases.insert(0, ns0.UpdatePerfIntervalRequestType_Def) + ns0.UpdatePerfInterval_Dec.__bases__ = tuple(bases) + + ns0.UpdatePerfIntervalRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdatePerfInterval_Dec_Holder" + + class UpdatePerfIntervalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdatePerfIntervalResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdatePerfIntervalResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdatePerfIntervalResponse") + kw["aname"] = "_UpdatePerfIntervalResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdatePerfIntervalResponse_Holder" + self.pyclass = Holder + + class GetDatabaseSizeEstimate_Dec(ElementDeclaration): + literal = "GetDatabaseSizeEstimate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GetDatabaseSizeEstimate") + kw["aname"] = "_GetDatabaseSizeEstimate" + if ns0.GetDatabaseSizeEstimateRequestType_Def not in ns0.GetDatabaseSizeEstimate_Dec.__bases__: + bases = list(ns0.GetDatabaseSizeEstimate_Dec.__bases__) + bases.insert(0, ns0.GetDatabaseSizeEstimateRequestType_Def) + ns0.GetDatabaseSizeEstimate_Dec.__bases__ = tuple(bases) + + ns0.GetDatabaseSizeEstimateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GetDatabaseSizeEstimate_Dec_Holder" + + class GetDatabaseSizeEstimateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GetDatabaseSizeEstimateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GetDatabaseSizeEstimateResponse_Dec.schema + TClist = [GTD("urn:vim25","DatabaseSizeEstimate",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GetDatabaseSizeEstimateResponse") + kw["aname"] = "_GetDatabaseSizeEstimateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "GetDatabaseSizeEstimateResponse_Holder" + self.pyclass = Holder + + class UpdateConfig_Dec(ElementDeclaration): + literal = "UpdateConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateConfig") + kw["aname"] = "_UpdateConfig" + if ns0.UpdateConfigRequestType_Def not in ns0.UpdateConfig_Dec.__bases__: + bases = list(ns0.UpdateConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateConfigRequestType_Def) + ns0.UpdateConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateConfig_Dec_Holder" + + class UpdateConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateConfigResponse") + kw["aname"] = "_UpdateConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateConfigResponse_Holder" + self.pyclass = Holder + + class MoveIntoResourcePool_Dec(ElementDeclaration): + literal = "MoveIntoResourcePool" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveIntoResourcePool") + kw["aname"] = "_MoveIntoResourcePool" + if ns0.MoveIntoResourcePoolRequestType_Def not in ns0.MoveIntoResourcePool_Dec.__bases__: + bases = list(ns0.MoveIntoResourcePool_Dec.__bases__) + bases.insert(0, ns0.MoveIntoResourcePoolRequestType_Def) + ns0.MoveIntoResourcePool_Dec.__bases__ = tuple(bases) + + ns0.MoveIntoResourcePoolRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveIntoResourcePool_Dec_Holder" + + class MoveIntoResourcePoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveIntoResourcePoolResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveIntoResourcePoolResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MoveIntoResourcePoolResponse") + kw["aname"] = "_MoveIntoResourcePoolResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MoveIntoResourcePoolResponse_Holder" + self.pyclass = Holder + + class UpdateChildResourceConfiguration_Dec(ElementDeclaration): + literal = "UpdateChildResourceConfiguration" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateChildResourceConfiguration") + kw["aname"] = "_UpdateChildResourceConfiguration" + if ns0.UpdateChildResourceConfigurationRequestType_Def not in ns0.UpdateChildResourceConfiguration_Dec.__bases__: + bases = list(ns0.UpdateChildResourceConfiguration_Dec.__bases__) + bases.insert(0, ns0.UpdateChildResourceConfigurationRequestType_Def) + ns0.UpdateChildResourceConfiguration_Dec.__bases__ = tuple(bases) + + ns0.UpdateChildResourceConfigurationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateChildResourceConfiguration_Dec_Holder" + + class UpdateChildResourceConfigurationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateChildResourceConfigurationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateChildResourceConfigurationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateChildResourceConfigurationResponse") + kw["aname"] = "_UpdateChildResourceConfigurationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateChildResourceConfigurationResponse_Holder" + self.pyclass = Holder + + class CreateResourcePool_Dec(ElementDeclaration): + literal = "CreateResourcePool" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateResourcePool") + kw["aname"] = "_CreateResourcePool" + if ns0.CreateResourcePoolRequestType_Def not in ns0.CreateResourcePool_Dec.__bases__: + bases = list(ns0.CreateResourcePool_Dec.__bases__) + bases.insert(0, ns0.CreateResourcePoolRequestType_Def) + ns0.CreateResourcePool_Dec.__bases__ = tuple(bases) + + ns0.CreateResourcePoolRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateResourcePool_Dec_Holder" + + class CreateResourcePoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateResourcePoolResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateResourcePoolResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateResourcePoolResponse") + kw["aname"] = "_CreateResourcePoolResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateResourcePoolResponse_Holder" + self.pyclass = Holder + + class DestroyChildren_Dec(ElementDeclaration): + literal = "DestroyChildren" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestroyChildren") + kw["aname"] = "_DestroyChildren" + if ns0.DestroyChildrenRequestType_Def not in ns0.DestroyChildren_Dec.__bases__: + bases = list(ns0.DestroyChildren_Dec.__bases__) + bases.insert(0, ns0.DestroyChildrenRequestType_Def) + ns0.DestroyChildren_Dec.__bases__ = tuple(bases) + + ns0.DestroyChildrenRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestroyChildren_Dec_Holder" + + class DestroyChildrenResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyChildrenResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyChildrenResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyChildrenResponse") + kw["aname"] = "_DestroyChildrenResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyChildrenResponse_Holder" + self.pyclass = Holder + + class CreateVApp_Dec(ElementDeclaration): + literal = "CreateVApp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateVApp") + kw["aname"] = "_CreateVApp" + if ns0.CreateVAppRequestType_Def not in ns0.CreateVApp_Dec.__bases__: + bases = list(ns0.CreateVApp_Dec.__bases__) + bases.insert(0, ns0.CreateVAppRequestType_Def) + ns0.CreateVApp_Dec.__bases__ = tuple(bases) + + ns0.CreateVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateVApp_Dec_Holder" + + class CreateVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateVAppResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateVAppResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateVAppResponse") + kw["aname"] = "_CreateVAppResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateVAppResponse_Holder" + self.pyclass = Holder + + class CreateChildVM_Dec(ElementDeclaration): + literal = "CreateChildVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateChildVM") + kw["aname"] = "_CreateChildVM" + if ns0.CreateChildVMRequestType_Def not in ns0.CreateChildVM_Dec.__bases__: + bases = list(ns0.CreateChildVM_Dec.__bases__) + bases.insert(0, ns0.CreateChildVMRequestType_Def) + ns0.CreateChildVM_Dec.__bases__ = tuple(bases) + + ns0.CreateChildVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateChildVM_Dec_Holder" + + class CreateChildVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateChildVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateChildVMResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateChildVMResponse") + kw["aname"] = "_CreateChildVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateChildVMResponse_Holder" + self.pyclass = Holder + + class CreateChildVM_Task_Dec(ElementDeclaration): + literal = "CreateChildVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateChildVM_Task") + kw["aname"] = "_CreateChildVM_Task" + if ns0.CreateChildVMRequestType_Def not in ns0.CreateChildVM_Task_Dec.__bases__: + bases = list(ns0.CreateChildVM_Task_Dec.__bases__) + bases.insert(0, ns0.CreateChildVMRequestType_Def) + ns0.CreateChildVM_Task_Dec.__bases__ = tuple(bases) + + ns0.CreateChildVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateChildVM_Task_Dec_Holder" + + class CreateChildVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateChildVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateChildVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateChildVM_TaskResponse") + kw["aname"] = "_CreateChildVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateChildVM_TaskResponse_Holder" + self.pyclass = Holder + + class RegisterChildVM_Dec(ElementDeclaration): + literal = "RegisterChildVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RegisterChildVM") + kw["aname"] = "_RegisterChildVM" + if ns0.RegisterChildVMRequestType_Def not in ns0.RegisterChildVM_Dec.__bases__: + bases = list(ns0.RegisterChildVM_Dec.__bases__) + bases.insert(0, ns0.RegisterChildVMRequestType_Def) + ns0.RegisterChildVM_Dec.__bases__ = tuple(bases) + + ns0.RegisterChildVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RegisterChildVM_Dec_Holder" + + class RegisterChildVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RegisterChildVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RegisterChildVMResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RegisterChildVMResponse") + kw["aname"] = "_RegisterChildVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RegisterChildVMResponse_Holder" + self.pyclass = Holder + + class RegisterChildVM_Task_Dec(ElementDeclaration): + literal = "RegisterChildVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RegisterChildVM_Task") + kw["aname"] = "_RegisterChildVM_Task" + if ns0.RegisterChildVMRequestType_Def not in ns0.RegisterChildVM_Task_Dec.__bases__: + bases = list(ns0.RegisterChildVM_Task_Dec.__bases__) + bases.insert(0, ns0.RegisterChildVMRequestType_Def) + ns0.RegisterChildVM_Task_Dec.__bases__ = tuple(bases) + + ns0.RegisterChildVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RegisterChildVM_Task_Dec_Holder" + + class RegisterChildVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RegisterChildVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RegisterChildVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RegisterChildVM_TaskResponse") + kw["aname"] = "_RegisterChildVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RegisterChildVM_TaskResponse_Holder" + self.pyclass = Holder + + class ImportVApp_Dec(ElementDeclaration): + literal = "ImportVApp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ImportVApp") + kw["aname"] = "_ImportVApp" + if ns0.ImportVAppRequestType_Def not in ns0.ImportVApp_Dec.__bases__: + bases = list(ns0.ImportVApp_Dec.__bases__) + bases.insert(0, ns0.ImportVAppRequestType_Def) + ns0.ImportVApp_Dec.__bases__ = tuple(bases) + + ns0.ImportVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ImportVApp_Dec_Holder" + + class ImportVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ImportVAppResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ImportVAppResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ImportVAppResponse") + kw["aname"] = "_ImportVAppResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ImportVAppResponse_Holder" + self.pyclass = Holder + + class FindByUuid_Dec(ElementDeclaration): + literal = "FindByUuid" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindByUuid") + kw["aname"] = "_FindByUuid" + if ns0.FindByUuidRequestType_Def not in ns0.FindByUuid_Dec.__bases__: + bases = list(ns0.FindByUuid_Dec.__bases__) + bases.insert(0, ns0.FindByUuidRequestType_Def) + ns0.FindByUuid_Dec.__bases__ = tuple(bases) + + ns0.FindByUuidRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindByUuid_Dec_Holder" + + class FindByUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindByUuidResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindByUuidResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindByUuidResponse") + kw["aname"] = "_FindByUuidResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FindByUuidResponse_Holder" + self.pyclass = Holder + + class FindByDatastorePath_Dec(ElementDeclaration): + literal = "FindByDatastorePath" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindByDatastorePath") + kw["aname"] = "_FindByDatastorePath" + if ns0.FindByDatastorePathRequestType_Def not in ns0.FindByDatastorePath_Dec.__bases__: + bases = list(ns0.FindByDatastorePath_Dec.__bases__) + bases.insert(0, ns0.FindByDatastorePathRequestType_Def) + ns0.FindByDatastorePath_Dec.__bases__ = tuple(bases) + + ns0.FindByDatastorePathRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindByDatastorePath_Dec_Holder" + + class FindByDatastorePathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindByDatastorePathResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindByDatastorePathResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindByDatastorePathResponse") + kw["aname"] = "_FindByDatastorePathResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FindByDatastorePathResponse_Holder" + self.pyclass = Holder + + class FindByDnsName_Dec(ElementDeclaration): + literal = "FindByDnsName" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindByDnsName") + kw["aname"] = "_FindByDnsName" + if ns0.FindByDnsNameRequestType_Def not in ns0.FindByDnsName_Dec.__bases__: + bases = list(ns0.FindByDnsName_Dec.__bases__) + bases.insert(0, ns0.FindByDnsNameRequestType_Def) + ns0.FindByDnsName_Dec.__bases__ = tuple(bases) + + ns0.FindByDnsNameRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindByDnsName_Dec_Holder" + + class FindByDnsNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindByDnsNameResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindByDnsNameResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindByDnsNameResponse") + kw["aname"] = "_FindByDnsNameResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FindByDnsNameResponse_Holder" + self.pyclass = Holder + + class FindByIp_Dec(ElementDeclaration): + literal = "FindByIp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindByIp") + kw["aname"] = "_FindByIp" + if ns0.FindByIpRequestType_Def not in ns0.FindByIp_Dec.__bases__: + bases = list(ns0.FindByIp_Dec.__bases__) + bases.insert(0, ns0.FindByIpRequestType_Def) + ns0.FindByIp_Dec.__bases__ = tuple(bases) + + ns0.FindByIpRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindByIp_Dec_Holder" + + class FindByIpResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindByIpResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindByIpResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindByIpResponse") + kw["aname"] = "_FindByIpResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FindByIpResponse_Holder" + self.pyclass = Holder + + class FindByInventoryPath_Dec(ElementDeclaration): + literal = "FindByInventoryPath" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindByInventoryPath") + kw["aname"] = "_FindByInventoryPath" + if ns0.FindByInventoryPathRequestType_Def not in ns0.FindByInventoryPath_Dec.__bases__: + bases = list(ns0.FindByInventoryPath_Dec.__bases__) + bases.insert(0, ns0.FindByInventoryPathRequestType_Def) + ns0.FindByInventoryPath_Dec.__bases__ = tuple(bases) + + ns0.FindByInventoryPathRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindByInventoryPath_Dec_Holder" + + class FindByInventoryPathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindByInventoryPathResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindByInventoryPathResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindByInventoryPathResponse") + kw["aname"] = "_FindByInventoryPathResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FindByInventoryPathResponse_Holder" + self.pyclass = Holder + + class FindChild_Dec(ElementDeclaration): + literal = "FindChild" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindChild") + kw["aname"] = "_FindChild" + if ns0.FindChildRequestType_Def not in ns0.FindChild_Dec.__bases__: + bases = list(ns0.FindChild_Dec.__bases__) + bases.insert(0, ns0.FindChildRequestType_Def) + ns0.FindChild_Dec.__bases__ = tuple(bases) + + ns0.FindChildRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindChild_Dec_Holder" + + class FindChildResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindChildResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindChildResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindChildResponse") + kw["aname"] = "_FindChildResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FindChildResponse_Holder" + self.pyclass = Holder + + class FindAllByUuid_Dec(ElementDeclaration): + literal = "FindAllByUuid" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindAllByUuid") + kw["aname"] = "_FindAllByUuid" + if ns0.FindAllByUuidRequestType_Def not in ns0.FindAllByUuid_Dec.__bases__: + bases = list(ns0.FindAllByUuid_Dec.__bases__) + bases.insert(0, ns0.FindAllByUuidRequestType_Def) + ns0.FindAllByUuid_Dec.__bases__ = tuple(bases) + + ns0.FindAllByUuidRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindAllByUuid_Dec_Holder" + + class FindAllByUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindAllByUuidResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindAllByUuidResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindAllByUuidResponse") + kw["aname"] = "_FindAllByUuidResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "FindAllByUuidResponse_Holder" + self.pyclass = Holder + + class FindAllByDnsName_Dec(ElementDeclaration): + literal = "FindAllByDnsName" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindAllByDnsName") + kw["aname"] = "_FindAllByDnsName" + if ns0.FindAllByDnsNameRequestType_Def not in ns0.FindAllByDnsName_Dec.__bases__: + bases = list(ns0.FindAllByDnsName_Dec.__bases__) + bases.insert(0, ns0.FindAllByDnsNameRequestType_Def) + ns0.FindAllByDnsName_Dec.__bases__ = tuple(bases) + + ns0.FindAllByDnsNameRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindAllByDnsName_Dec_Holder" + + class FindAllByDnsNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindAllByDnsNameResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindAllByDnsNameResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindAllByDnsNameResponse") + kw["aname"] = "_FindAllByDnsNameResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "FindAllByDnsNameResponse_Holder" + self.pyclass = Holder + + class FindAllByIp_Dec(ElementDeclaration): + literal = "FindAllByIp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FindAllByIp") + kw["aname"] = "_FindAllByIp" + if ns0.FindAllByIpRequestType_Def not in ns0.FindAllByIp_Dec.__bases__: + bases = list(ns0.FindAllByIp_Dec.__bases__) + bases.insert(0, ns0.FindAllByIpRequestType_Def) + ns0.FindAllByIp_Dec.__bases__ = tuple(bases) + + ns0.FindAllByIpRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FindAllByIp_Dec_Holder" + + class FindAllByIpResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FindAllByIpResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FindAllByIpResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FindAllByIpResponse") + kw["aname"] = "_FindAllByIpResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "FindAllByIpResponse_Holder" + self.pyclass = Holder + + class CurrentTime_Dec(ElementDeclaration): + literal = "CurrentTime" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CurrentTime") + kw["aname"] = "_CurrentTime" + if ns0.CurrentTimeRequestType_Def not in ns0.CurrentTime_Dec.__bases__: + bases = list(ns0.CurrentTime_Dec.__bases__) + bases.insert(0, ns0.CurrentTimeRequestType_Def) + ns0.CurrentTime_Dec.__bases__ = tuple(bases) + + ns0.CurrentTimeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CurrentTime_Dec_Holder" + + class CurrentTimeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CurrentTimeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CurrentTimeResponse_Dec.schema + TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CurrentTimeResponse") + kw["aname"] = "_CurrentTimeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CurrentTimeResponse_Holder" + self.pyclass = Holder + + class RetrieveServiceContent_Dec(ElementDeclaration): + literal = "RetrieveServiceContent" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveServiceContent") + kw["aname"] = "_RetrieveServiceContent" + if ns0.RetrieveServiceContentRequestType_Def not in ns0.RetrieveServiceContent_Dec.__bases__: + bases = list(ns0.RetrieveServiceContent_Dec.__bases__) + bases.insert(0, ns0.RetrieveServiceContentRequestType_Def) + ns0.RetrieveServiceContent_Dec.__bases__ = tuple(bases) + + ns0.RetrieveServiceContentRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveServiceContent_Dec_Holder" + + class RetrieveServiceContentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveServiceContentResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveServiceContentResponse_Dec.schema + TClist = [GTD("urn:vim25","ServiceContent",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveServiceContentResponse") + kw["aname"] = "_RetrieveServiceContentResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RetrieveServiceContentResponse_Holder" + self.pyclass = Holder + + class ValidateMigration_Dec(ElementDeclaration): + literal = "ValidateMigration" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ValidateMigration") + kw["aname"] = "_ValidateMigration" + if ns0.ValidateMigrationRequestType_Def not in ns0.ValidateMigration_Dec.__bases__: + bases = list(ns0.ValidateMigration_Dec.__bases__) + bases.insert(0, ns0.ValidateMigrationRequestType_Def) + ns0.ValidateMigration_Dec.__bases__ = tuple(bases) + + ns0.ValidateMigrationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ValidateMigration_Dec_Holder" + + class ValidateMigrationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ValidateMigrationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ValidateMigrationResponse_Dec.schema + TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ValidateMigrationResponse") + kw["aname"] = "_ValidateMigrationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ValidateMigrationResponse_Holder" + self.pyclass = Holder + + class QueryVMotionCompatibility_Dec(ElementDeclaration): + literal = "QueryVMotionCompatibility" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVMotionCompatibility") + kw["aname"] = "_QueryVMotionCompatibility" + if ns0.QueryVMotionCompatibilityRequestType_Def not in ns0.QueryVMotionCompatibility_Dec.__bases__: + bases = list(ns0.QueryVMotionCompatibility_Dec.__bases__) + bases.insert(0, ns0.QueryVMotionCompatibilityRequestType_Def) + ns0.QueryVMotionCompatibility_Dec.__bases__ = tuple(bases) + + ns0.QueryVMotionCompatibilityRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVMotionCompatibility_Dec_Holder" + + class QueryVMotionCompatibilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVMotionCompatibilityResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVMotionCompatibilityResponse_Dec.schema + TClist = [GTD("urn:vim25","HostVMotionCompatibility",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityResponse") + kw["aname"] = "_QueryVMotionCompatibilityResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryVMotionCompatibilityResponse_Holder" + self.pyclass = Holder + + class RetrieveProductComponents_Dec(ElementDeclaration): + literal = "RetrieveProductComponents" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveProductComponents") + kw["aname"] = "_RetrieveProductComponents" + if ns0.RetrieveProductComponentsRequestType_Def not in ns0.RetrieveProductComponents_Dec.__bases__: + bases = list(ns0.RetrieveProductComponents_Dec.__bases__) + bases.insert(0, ns0.RetrieveProductComponentsRequestType_Def) + ns0.RetrieveProductComponents_Dec.__bases__ = tuple(bases) + + ns0.RetrieveProductComponentsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveProductComponents_Dec_Holder" + + class RetrieveProductComponentsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveProductComponentsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveProductComponentsResponse_Dec.schema + TClist = [GTD("urn:vim25","ProductComponentInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveProductComponentsResponse") + kw["aname"] = "_RetrieveProductComponentsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveProductComponentsResponse_Holder" + self.pyclass = Holder + + class UpdateServiceMessage_Dec(ElementDeclaration): + literal = "UpdateServiceMessage" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateServiceMessage") + kw["aname"] = "_UpdateServiceMessage" + if ns0.UpdateServiceMessageRequestType_Def not in ns0.UpdateServiceMessage_Dec.__bases__: + bases = list(ns0.UpdateServiceMessage_Dec.__bases__) + bases.insert(0, ns0.UpdateServiceMessageRequestType_Def) + ns0.UpdateServiceMessage_Dec.__bases__ = tuple(bases) + + ns0.UpdateServiceMessageRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateServiceMessage_Dec_Holder" + + class UpdateServiceMessageResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateServiceMessageResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateServiceMessageResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateServiceMessageResponse") + kw["aname"] = "_UpdateServiceMessageResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateServiceMessageResponse_Holder" + self.pyclass = Holder + + class Login_Dec(ElementDeclaration): + literal = "Login" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Login") + kw["aname"] = "_Login" + if ns0.LoginRequestType_Def not in ns0.Login_Dec.__bases__: + bases = list(ns0.Login_Dec.__bases__) + bases.insert(0, ns0.LoginRequestType_Def) + ns0.Login_Dec.__bases__ = tuple(bases) + + ns0.LoginRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Login_Dec_Holder" + + class LoginResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "LoginResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.LoginResponse_Dec.schema + TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","LoginResponse") + kw["aname"] = "_LoginResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "LoginResponse_Holder" + self.pyclass = Holder + + class LoginBySSPI_Dec(ElementDeclaration): + literal = "LoginBySSPI" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LoginBySSPI") + kw["aname"] = "_LoginBySSPI" + if ns0.LoginBySSPIRequestType_Def not in ns0.LoginBySSPI_Dec.__bases__: + bases = list(ns0.LoginBySSPI_Dec.__bases__) + bases.insert(0, ns0.LoginBySSPIRequestType_Def) + ns0.LoginBySSPI_Dec.__bases__ = tuple(bases) + + ns0.LoginBySSPIRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LoginBySSPI_Dec_Holder" + + class LoginBySSPIResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "LoginBySSPIResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.LoginBySSPIResponse_Dec.schema + TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","LoginBySSPIResponse") + kw["aname"] = "_LoginBySSPIResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "LoginBySSPIResponse_Holder" + self.pyclass = Holder + + class Logout_Dec(ElementDeclaration): + literal = "Logout" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Logout") + kw["aname"] = "_Logout" + if ns0.LogoutRequestType_Def not in ns0.Logout_Dec.__bases__: + bases = list(ns0.Logout_Dec.__bases__) + bases.insert(0, ns0.LogoutRequestType_Def) + ns0.Logout_Dec.__bases__ = tuple(bases) + + ns0.LogoutRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Logout_Dec_Holder" + + class LogoutResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "LogoutResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.LogoutResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","LogoutResponse") + kw["aname"] = "_LogoutResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "LogoutResponse_Holder" + self.pyclass = Holder + + class AcquireLocalTicket_Dec(ElementDeclaration): + literal = "AcquireLocalTicket" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AcquireLocalTicket") + kw["aname"] = "_AcquireLocalTicket" + if ns0.AcquireLocalTicketRequestType_Def not in ns0.AcquireLocalTicket_Dec.__bases__: + bases = list(ns0.AcquireLocalTicket_Dec.__bases__) + bases.insert(0, ns0.AcquireLocalTicketRequestType_Def) + ns0.AcquireLocalTicket_Dec.__bases__ = tuple(bases) + + ns0.AcquireLocalTicketRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AcquireLocalTicket_Dec_Holder" + + class AcquireLocalTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AcquireLocalTicketResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AcquireLocalTicketResponse_Dec.schema + TClist = [GTD("urn:vim25","SessionManagerLocalTicket",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AcquireLocalTicketResponse") + kw["aname"] = "_AcquireLocalTicketResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AcquireLocalTicketResponse_Holder" + self.pyclass = Holder + + class TerminateSession_Dec(ElementDeclaration): + literal = "TerminateSession" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TerminateSession") + kw["aname"] = "_TerminateSession" + if ns0.TerminateSessionRequestType_Def not in ns0.TerminateSession_Dec.__bases__: + bases = list(ns0.TerminateSession_Dec.__bases__) + bases.insert(0, ns0.TerminateSessionRequestType_Def) + ns0.TerminateSession_Dec.__bases__ = tuple(bases) + + ns0.TerminateSessionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TerminateSession_Dec_Holder" + + class TerminateSessionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "TerminateSessionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.TerminateSessionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","TerminateSessionResponse") + kw["aname"] = "_TerminateSessionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "TerminateSessionResponse_Holder" + self.pyclass = Holder + + class SetLocale_Dec(ElementDeclaration): + literal = "SetLocale" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetLocale") + kw["aname"] = "_SetLocale" + if ns0.SetLocaleRequestType_Def not in ns0.SetLocale_Dec.__bases__: + bases = list(ns0.SetLocale_Dec.__bases__) + bases.insert(0, ns0.SetLocaleRequestType_Def) + ns0.SetLocale_Dec.__bases__ = tuple(bases) + + ns0.SetLocaleRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetLocale_Dec_Holder" + + class SetLocaleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetLocaleResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetLocaleResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetLocaleResponse") + kw["aname"] = "_SetLocaleResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetLocaleResponse_Holder" + self.pyclass = Holder + + class LoginExtensionBySubjectName_Dec(ElementDeclaration): + literal = "LoginExtensionBySubjectName" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LoginExtensionBySubjectName") + kw["aname"] = "_LoginExtensionBySubjectName" + if ns0.LoginExtensionBySubjectNameRequestType_Def not in ns0.LoginExtensionBySubjectName_Dec.__bases__: + bases = list(ns0.LoginExtensionBySubjectName_Dec.__bases__) + bases.insert(0, ns0.LoginExtensionBySubjectNameRequestType_Def) + ns0.LoginExtensionBySubjectName_Dec.__bases__ = tuple(bases) + + ns0.LoginExtensionBySubjectNameRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LoginExtensionBySubjectName_Dec_Holder" + + class LoginExtensionBySubjectNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "LoginExtensionBySubjectNameResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.LoginExtensionBySubjectNameResponse_Dec.schema + TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","LoginExtensionBySubjectNameResponse") + kw["aname"] = "_LoginExtensionBySubjectNameResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "LoginExtensionBySubjectNameResponse_Holder" + self.pyclass = Holder + + class ImpersonateUser_Dec(ElementDeclaration): + literal = "ImpersonateUser" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ImpersonateUser") + kw["aname"] = "_ImpersonateUser" + if ns0.ImpersonateUserRequestType_Def not in ns0.ImpersonateUser_Dec.__bases__: + bases = list(ns0.ImpersonateUser_Dec.__bases__) + bases.insert(0, ns0.ImpersonateUserRequestType_Def) + ns0.ImpersonateUser_Dec.__bases__ = tuple(bases) + + ns0.ImpersonateUserRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ImpersonateUser_Dec_Holder" + + class ImpersonateUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ImpersonateUserResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ImpersonateUserResponse_Dec.schema + TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ImpersonateUserResponse") + kw["aname"] = "_ImpersonateUserResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ImpersonateUserResponse_Holder" + self.pyclass = Holder + + class SessionIsActive_Dec(ElementDeclaration): + literal = "SessionIsActive" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SessionIsActive") + kw["aname"] = "_SessionIsActive" + if ns0.SessionIsActiveRequestType_Def not in ns0.SessionIsActive_Dec.__bases__: + bases = list(ns0.SessionIsActive_Dec.__bases__) + bases.insert(0, ns0.SessionIsActiveRequestType_Def) + ns0.SessionIsActive_Dec.__bases__ = tuple(bases) + + ns0.SessionIsActiveRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SessionIsActive_Dec_Holder" + + class SessionIsActiveResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SessionIsActiveResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SessionIsActiveResponse_Dec.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","SessionIsActiveResponse") + kw["aname"] = "_SessionIsActiveResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "SessionIsActiveResponse_Holder" + self.pyclass = Holder + + class AcquireCloneTicket_Dec(ElementDeclaration): + literal = "AcquireCloneTicket" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AcquireCloneTicket") + kw["aname"] = "_AcquireCloneTicket" + if ns0.AcquireCloneTicketRequestType_Def not in ns0.AcquireCloneTicket_Dec.__bases__: + bases = list(ns0.AcquireCloneTicket_Dec.__bases__) + bases.insert(0, ns0.AcquireCloneTicketRequestType_Def) + ns0.AcquireCloneTicket_Dec.__bases__ = tuple(bases) + + ns0.AcquireCloneTicketRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AcquireCloneTicket_Dec_Holder" + + class AcquireCloneTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AcquireCloneTicketResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AcquireCloneTicketResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AcquireCloneTicketResponse") + kw["aname"] = "_AcquireCloneTicketResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AcquireCloneTicketResponse_Holder" + self.pyclass = Holder + + class CloneSession_Dec(ElementDeclaration): + literal = "CloneSession" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CloneSession") + kw["aname"] = "_CloneSession" + if ns0.CloneSessionRequestType_Def not in ns0.CloneSession_Dec.__bases__: + bases = list(ns0.CloneSession_Dec.__bases__) + bases.insert(0, ns0.CloneSessionRequestType_Def) + ns0.CloneSession_Dec.__bases__ = tuple(bases) + + ns0.CloneSessionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CloneSession_Dec_Holder" + + class CloneSessionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CloneSessionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CloneSessionResponse_Dec.schema + TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CloneSessionResponse") + kw["aname"] = "_CloneSessionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CloneSessionResponse_Holder" + self.pyclass = Holder + + class CancelTask_Dec(ElementDeclaration): + literal = "CancelTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CancelTask") + kw["aname"] = "_CancelTask" + if ns0.CancelTaskRequestType_Def not in ns0.CancelTask_Dec.__bases__: + bases = list(ns0.CancelTask_Dec.__bases__) + bases.insert(0, ns0.CancelTaskRequestType_Def) + ns0.CancelTask_Dec.__bases__ = tuple(bases) + + ns0.CancelTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CancelTask_Dec_Holder" + + class CancelTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CancelTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CancelTaskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CancelTaskResponse") + kw["aname"] = "_CancelTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CancelTaskResponse_Holder" + self.pyclass = Holder + + class UpdateProgress_Dec(ElementDeclaration): + literal = "UpdateProgress" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateProgress") + kw["aname"] = "_UpdateProgress" + if ns0.UpdateProgressRequestType_Def not in ns0.UpdateProgress_Dec.__bases__: + bases = list(ns0.UpdateProgress_Dec.__bases__) + bases.insert(0, ns0.UpdateProgressRequestType_Def) + ns0.UpdateProgress_Dec.__bases__ = tuple(bases) + + ns0.UpdateProgressRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateProgress_Dec_Holder" + + class UpdateProgressResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateProgressResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateProgressResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateProgressResponse") + kw["aname"] = "_UpdateProgressResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateProgressResponse_Holder" + self.pyclass = Holder + + class SetTaskState_Dec(ElementDeclaration): + literal = "SetTaskState" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetTaskState") + kw["aname"] = "_SetTaskState" + if ns0.SetTaskStateRequestType_Def not in ns0.SetTaskState_Dec.__bases__: + bases = list(ns0.SetTaskState_Dec.__bases__) + bases.insert(0, ns0.SetTaskStateRequestType_Def) + ns0.SetTaskState_Dec.__bases__ = tuple(bases) + + ns0.SetTaskStateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetTaskState_Dec_Holder" + + class SetTaskStateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetTaskStateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetTaskStateResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetTaskStateResponse") + kw["aname"] = "_SetTaskStateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetTaskStateResponse_Holder" + self.pyclass = Holder + + class SetTaskDescription_Dec(ElementDeclaration): + literal = "SetTaskDescription" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetTaskDescription") + kw["aname"] = "_SetTaskDescription" + if ns0.SetTaskDescriptionRequestType_Def not in ns0.SetTaskDescription_Dec.__bases__: + bases = list(ns0.SetTaskDescription_Dec.__bases__) + bases.insert(0, ns0.SetTaskDescriptionRequestType_Def) + ns0.SetTaskDescription_Dec.__bases__ = tuple(bases) + + ns0.SetTaskDescriptionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetTaskDescription_Dec_Holder" + + class SetTaskDescriptionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetTaskDescriptionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetTaskDescriptionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetTaskDescriptionResponse") + kw["aname"] = "_SetTaskDescriptionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetTaskDescriptionResponse_Holder" + self.pyclass = Holder + + class ReadNextTasks_Dec(ElementDeclaration): + literal = "ReadNextTasks" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReadNextTasks") + kw["aname"] = "_ReadNextTasks" + if ns0.ReadNextTasksRequestType_Def not in ns0.ReadNextTasks_Dec.__bases__: + bases = list(ns0.ReadNextTasks_Dec.__bases__) + bases.insert(0, ns0.ReadNextTasksRequestType_Def) + ns0.ReadNextTasks_Dec.__bases__ = tuple(bases) + + ns0.ReadNextTasksRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReadNextTasks_Dec_Holder" + + class ReadNextTasksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReadNextTasksResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReadNextTasksResponse_Dec.schema + TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReadNextTasksResponse") + kw["aname"] = "_ReadNextTasksResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ReadNextTasksResponse_Holder" + self.pyclass = Holder + + class ReadPreviousTasks_Dec(ElementDeclaration): + literal = "ReadPreviousTasks" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReadPreviousTasks") + kw["aname"] = "_ReadPreviousTasks" + if ns0.ReadPreviousTasksRequestType_Def not in ns0.ReadPreviousTasks_Dec.__bases__: + bases = list(ns0.ReadPreviousTasks_Dec.__bases__) + bases.insert(0, ns0.ReadPreviousTasksRequestType_Def) + ns0.ReadPreviousTasks_Dec.__bases__ = tuple(bases) + + ns0.ReadPreviousTasksRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReadPreviousTasks_Dec_Holder" + + class ReadPreviousTasksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReadPreviousTasksResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReadPreviousTasksResponse_Dec.schema + TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReadPreviousTasksResponse") + kw["aname"] = "_ReadPreviousTasksResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ReadPreviousTasksResponse_Holder" + self.pyclass = Holder + + class CreateCollectorForTasks_Dec(ElementDeclaration): + literal = "CreateCollectorForTasks" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateCollectorForTasks") + kw["aname"] = "_CreateCollectorForTasks" + if ns0.CreateCollectorForTasksRequestType_Def not in ns0.CreateCollectorForTasks_Dec.__bases__: + bases = list(ns0.CreateCollectorForTasks_Dec.__bases__) + bases.insert(0, ns0.CreateCollectorForTasksRequestType_Def) + ns0.CreateCollectorForTasks_Dec.__bases__ = tuple(bases) + + ns0.CreateCollectorForTasksRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateCollectorForTasks_Dec_Holder" + + class CreateCollectorForTasksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateCollectorForTasksResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateCollectorForTasksResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateCollectorForTasksResponse") + kw["aname"] = "_CreateCollectorForTasksResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateCollectorForTasksResponse_Holder" + self.pyclass = Holder + + class CreateTask_Dec(ElementDeclaration): + literal = "CreateTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateTask") + kw["aname"] = "_CreateTask" + if ns0.CreateTaskRequestType_Def not in ns0.CreateTask_Dec.__bases__: + bases = list(ns0.CreateTask_Dec.__bases__) + bases.insert(0, ns0.CreateTaskRequestType_Def) + ns0.CreateTask_Dec.__bases__ = tuple(bases) + + ns0.CreateTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateTask_Dec_Holder" + + class CreateTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateTaskResponse_Dec.schema + TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateTaskResponse") + kw["aname"] = "_CreateTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateTaskResponse_Holder" + self.pyclass = Holder + + class RetrieveUserGroups_Dec(ElementDeclaration): + literal = "RetrieveUserGroups" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveUserGroups") + kw["aname"] = "_RetrieveUserGroups" + if ns0.RetrieveUserGroupsRequestType_Def not in ns0.RetrieveUserGroups_Dec.__bases__: + bases = list(ns0.RetrieveUserGroups_Dec.__bases__) + bases.insert(0, ns0.RetrieveUserGroupsRequestType_Def) + ns0.RetrieveUserGroups_Dec.__bases__ = tuple(bases) + + ns0.RetrieveUserGroupsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveUserGroups_Dec_Holder" + + class RetrieveUserGroupsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveUserGroupsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveUserGroupsResponse_Dec.schema + TClist = [GTD("urn:vim25","UserSearchResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveUserGroupsResponse") + kw["aname"] = "_RetrieveUserGroupsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveUserGroupsResponse_Holder" + self.pyclass = Holder + + class UpdateVAppConfig_Dec(ElementDeclaration): + literal = "UpdateVAppConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateVAppConfig") + kw["aname"] = "_UpdateVAppConfig" + if ns0.UpdateVAppConfigRequestType_Def not in ns0.UpdateVAppConfig_Dec.__bases__: + bases = list(ns0.UpdateVAppConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateVAppConfigRequestType_Def) + ns0.UpdateVAppConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateVAppConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateVAppConfig_Dec_Holder" + + class UpdateVAppConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateVAppConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateVAppConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateVAppConfigResponse") + kw["aname"] = "_UpdateVAppConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateVAppConfigResponse_Holder" + self.pyclass = Holder + + class CloneVApp_Dec(ElementDeclaration): + literal = "CloneVApp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CloneVApp") + kw["aname"] = "_CloneVApp" + if ns0.CloneVAppRequestType_Def not in ns0.CloneVApp_Dec.__bases__: + bases = list(ns0.CloneVApp_Dec.__bases__) + bases.insert(0, ns0.CloneVAppRequestType_Def) + ns0.CloneVApp_Dec.__bases__ = tuple(bases) + + ns0.CloneVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CloneVApp_Dec_Holder" + + class CloneVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CloneVAppResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CloneVAppResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CloneVAppResponse") + kw["aname"] = "_CloneVAppResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CloneVAppResponse_Holder" + self.pyclass = Holder + + class CloneVApp_Task_Dec(ElementDeclaration): + literal = "CloneVApp_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CloneVApp_Task") + kw["aname"] = "_CloneVApp_Task" + if ns0.CloneVAppRequestType_Def not in ns0.CloneVApp_Task_Dec.__bases__: + bases = list(ns0.CloneVApp_Task_Dec.__bases__) + bases.insert(0, ns0.CloneVAppRequestType_Def) + ns0.CloneVApp_Task_Dec.__bases__ = tuple(bases) + + ns0.CloneVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CloneVApp_Task_Dec_Holder" + + class CloneVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CloneVApp_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CloneVApp_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CloneVApp_TaskResponse") + kw["aname"] = "_CloneVApp_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CloneVApp_TaskResponse_Holder" + self.pyclass = Holder + + class ExportVApp_Dec(ElementDeclaration): + literal = "ExportVApp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExportVApp") + kw["aname"] = "_ExportVApp" + if ns0.ExportVAppRequestType_Def not in ns0.ExportVApp_Dec.__bases__: + bases = list(ns0.ExportVApp_Dec.__bases__) + bases.insert(0, ns0.ExportVAppRequestType_Def) + ns0.ExportVApp_Dec.__bases__ = tuple(bases) + + ns0.ExportVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExportVApp_Dec_Holder" + + class ExportVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExportVAppResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExportVAppResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ExportVAppResponse") + kw["aname"] = "_ExportVAppResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ExportVAppResponse_Holder" + self.pyclass = Holder + + class PowerOnVApp_Dec(ElementDeclaration): + literal = "PowerOnVApp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnVApp") + kw["aname"] = "_PowerOnVApp" + if ns0.PowerOnVAppRequestType_Def not in ns0.PowerOnVApp_Dec.__bases__: + bases = list(ns0.PowerOnVApp_Dec.__bases__) + bases.insert(0, ns0.PowerOnVAppRequestType_Def) + ns0.PowerOnVApp_Dec.__bases__ = tuple(bases) + + ns0.PowerOnVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVApp_Dec_Holder" + + class PowerOnVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOnVAppResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOnVAppResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PowerOnVAppResponse") + kw["aname"] = "_PowerOnVAppResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PowerOnVAppResponse_Holder" + self.pyclass = Holder + + class PowerOnVApp_Task_Dec(ElementDeclaration): + literal = "PowerOnVApp_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnVApp_Task") + kw["aname"] = "_PowerOnVApp_Task" + if ns0.PowerOnVAppRequestType_Def not in ns0.PowerOnVApp_Task_Dec.__bases__: + bases = list(ns0.PowerOnVApp_Task_Dec.__bases__) + bases.insert(0, ns0.PowerOnVAppRequestType_Def) + ns0.PowerOnVApp_Task_Dec.__bases__ = tuple(bases) + + ns0.PowerOnVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVApp_Task_Dec_Holder" + + class PowerOnVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOnVApp_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOnVApp_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerOnVApp_TaskResponse") + kw["aname"] = "_PowerOnVApp_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerOnVApp_TaskResponse_Holder" + self.pyclass = Holder + + class PowerOffVApp_Dec(ElementDeclaration): + literal = "PowerOffVApp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOffVApp") + kw["aname"] = "_PowerOffVApp" + if ns0.PowerOffVAppRequestType_Def not in ns0.PowerOffVApp_Dec.__bases__: + bases = list(ns0.PowerOffVApp_Dec.__bases__) + bases.insert(0, ns0.PowerOffVAppRequestType_Def) + ns0.PowerOffVApp_Dec.__bases__ = tuple(bases) + + ns0.PowerOffVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVApp_Dec_Holder" + + class PowerOffVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOffVAppResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOffVAppResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PowerOffVAppResponse") + kw["aname"] = "_PowerOffVAppResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PowerOffVAppResponse_Holder" + self.pyclass = Holder + + class PowerOffVApp_Task_Dec(ElementDeclaration): + literal = "PowerOffVApp_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOffVApp_Task") + kw["aname"] = "_PowerOffVApp_Task" + if ns0.PowerOffVAppRequestType_Def not in ns0.PowerOffVApp_Task_Dec.__bases__: + bases = list(ns0.PowerOffVApp_Task_Dec.__bases__) + bases.insert(0, ns0.PowerOffVAppRequestType_Def) + ns0.PowerOffVApp_Task_Dec.__bases__ = tuple(bases) + + ns0.PowerOffVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVApp_Task_Dec_Holder" + + class PowerOffVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOffVApp_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOffVApp_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerOffVApp_TaskResponse") + kw["aname"] = "_PowerOffVApp_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerOffVApp_TaskResponse_Holder" + self.pyclass = Holder + + class unregisterVApp_Dec(ElementDeclaration): + literal = "unregisterVApp" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","unregisterVApp") + kw["aname"] = "_unregisterVApp" + if ns0.unregisterVAppRequestType_Def not in ns0.unregisterVApp_Dec.__bases__: + bases = list(ns0.unregisterVApp_Dec.__bases__) + bases.insert(0, ns0.unregisterVAppRequestType_Def) + ns0.unregisterVApp_Dec.__bases__ = tuple(bases) + + ns0.unregisterVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "unregisterVApp_Dec_Holder" + + class unregisterVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "unregisterVAppResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.unregisterVAppResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","unregisterVAppResponse") + kw["aname"] = "_unregisterVAppResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "unregisterVAppResponse_Holder" + self.pyclass = Holder + + class unregisterVApp_Task_Dec(ElementDeclaration): + literal = "unregisterVApp_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","unregisterVApp_Task") + kw["aname"] = "_unregisterVApp_Task" + if ns0.unregisterVAppRequestType_Def not in ns0.unregisterVApp_Task_Dec.__bases__: + bases = list(ns0.unregisterVApp_Task_Dec.__bases__) + bases.insert(0, ns0.unregisterVAppRequestType_Def) + ns0.unregisterVApp_Task_Dec.__bases__ = tuple(bases) + + ns0.unregisterVAppRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "unregisterVApp_Task_Dec_Holder" + + class unregisterVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "unregisterVApp_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.unregisterVApp_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","unregisterVApp_TaskResponse") + kw["aname"] = "_unregisterVApp_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "unregisterVApp_TaskResponse_Holder" + self.pyclass = Holder + + class CreateVirtualDisk_Dec(ElementDeclaration): + literal = "CreateVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateVirtualDisk") + kw["aname"] = "_CreateVirtualDisk" + if ns0.CreateVirtualDiskRequestType_Def not in ns0.CreateVirtualDisk_Dec.__bases__: + bases = list(ns0.CreateVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.CreateVirtualDiskRequestType_Def) + ns0.CreateVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.CreateVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateVirtualDisk_Dec_Holder" + + class CreateVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateVirtualDiskResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateVirtualDiskResponse") + kw["aname"] = "_CreateVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateVirtualDiskResponse_Holder" + self.pyclass = Holder + + class CreateVirtualDisk_Task_Dec(ElementDeclaration): + literal = "CreateVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateVirtualDisk_Task") + kw["aname"] = "_CreateVirtualDisk_Task" + if ns0.CreateVirtualDiskRequestType_Def not in ns0.CreateVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.CreateVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.CreateVirtualDiskRequestType_Def) + ns0.CreateVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.CreateVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateVirtualDisk_Task_Dec_Holder" + + class CreateVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateVirtualDisk_TaskResponse") + kw["aname"] = "_CreateVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class DeleteVirtualDisk_Dec(ElementDeclaration): + literal = "DeleteVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeleteVirtualDisk") + kw["aname"] = "_DeleteVirtualDisk" + if ns0.DeleteVirtualDiskRequestType_Def not in ns0.DeleteVirtualDisk_Dec.__bases__: + bases = list(ns0.DeleteVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.DeleteVirtualDiskRequestType_Def) + ns0.DeleteVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.DeleteVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeleteVirtualDisk_Dec_Holder" + + class DeleteVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DeleteVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DeleteVirtualDiskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DeleteVirtualDiskResponse") + kw["aname"] = "_DeleteVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DeleteVirtualDiskResponse_Holder" + self.pyclass = Holder + + class DeleteVirtualDisk_Task_Dec(ElementDeclaration): + literal = "DeleteVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeleteVirtualDisk_Task") + kw["aname"] = "_DeleteVirtualDisk_Task" + if ns0.DeleteVirtualDiskRequestType_Def not in ns0.DeleteVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.DeleteVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.DeleteVirtualDiskRequestType_Def) + ns0.DeleteVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.DeleteVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeleteVirtualDisk_Task_Dec_Holder" + + class DeleteVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DeleteVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DeleteVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DeleteVirtualDisk_TaskResponse") + kw["aname"] = "_DeleteVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DeleteVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class MoveVirtualDisk_Dec(ElementDeclaration): + literal = "MoveVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveVirtualDisk") + kw["aname"] = "_MoveVirtualDisk" + if ns0.MoveVirtualDiskRequestType_Def not in ns0.MoveVirtualDisk_Dec.__bases__: + bases = list(ns0.MoveVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.MoveVirtualDiskRequestType_Def) + ns0.MoveVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.MoveVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveVirtualDisk_Dec_Holder" + + class MoveVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveVirtualDiskResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MoveVirtualDiskResponse") + kw["aname"] = "_MoveVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MoveVirtualDiskResponse_Holder" + self.pyclass = Holder + + class MoveVirtualDisk_Task_Dec(ElementDeclaration): + literal = "MoveVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MoveVirtualDisk_Task") + kw["aname"] = "_MoveVirtualDisk_Task" + if ns0.MoveVirtualDiskRequestType_Def not in ns0.MoveVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.MoveVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.MoveVirtualDiskRequestType_Def) + ns0.MoveVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.MoveVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MoveVirtualDisk_Task_Dec_Holder" + + class MoveVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MoveVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MoveVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MoveVirtualDisk_TaskResponse") + kw["aname"] = "_MoveVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MoveVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class CopyVirtualDisk_Dec(ElementDeclaration): + literal = "CopyVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CopyVirtualDisk") + kw["aname"] = "_CopyVirtualDisk" + if ns0.CopyVirtualDiskRequestType_Def not in ns0.CopyVirtualDisk_Dec.__bases__: + bases = list(ns0.CopyVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.CopyVirtualDiskRequestType_Def) + ns0.CopyVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.CopyVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CopyVirtualDisk_Dec_Holder" + + class CopyVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CopyVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CopyVirtualDiskResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CopyVirtualDiskResponse") + kw["aname"] = "_CopyVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CopyVirtualDiskResponse_Holder" + self.pyclass = Holder + + class CopyVirtualDisk_Task_Dec(ElementDeclaration): + literal = "CopyVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CopyVirtualDisk_Task") + kw["aname"] = "_CopyVirtualDisk_Task" + if ns0.CopyVirtualDiskRequestType_Def not in ns0.CopyVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.CopyVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.CopyVirtualDiskRequestType_Def) + ns0.CopyVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.CopyVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CopyVirtualDisk_Task_Dec_Holder" + + class CopyVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CopyVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CopyVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CopyVirtualDisk_TaskResponse") + kw["aname"] = "_CopyVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CopyVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class ExtendVirtualDisk_Dec(ElementDeclaration): + literal = "ExtendVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExtendVirtualDisk") + kw["aname"] = "_ExtendVirtualDisk" + if ns0.ExtendVirtualDiskRequestType_Def not in ns0.ExtendVirtualDisk_Dec.__bases__: + bases = list(ns0.ExtendVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.ExtendVirtualDiskRequestType_Def) + ns0.ExtendVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.ExtendVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExtendVirtualDisk_Dec_Holder" + + class ExtendVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExtendVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExtendVirtualDiskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ExtendVirtualDiskResponse") + kw["aname"] = "_ExtendVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ExtendVirtualDiskResponse_Holder" + self.pyclass = Holder + + class ExtendVirtualDisk_Task_Dec(ElementDeclaration): + literal = "ExtendVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExtendVirtualDisk_Task") + kw["aname"] = "_ExtendVirtualDisk_Task" + if ns0.ExtendVirtualDiskRequestType_Def not in ns0.ExtendVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.ExtendVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.ExtendVirtualDiskRequestType_Def) + ns0.ExtendVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.ExtendVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExtendVirtualDisk_Task_Dec_Holder" + + class ExtendVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExtendVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExtendVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ExtendVirtualDisk_TaskResponse") + kw["aname"] = "_ExtendVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ExtendVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class QueryVirtualDiskFragmentation_Dec(ElementDeclaration): + literal = "QueryVirtualDiskFragmentation" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVirtualDiskFragmentation") + kw["aname"] = "_QueryVirtualDiskFragmentation" + if ns0.QueryVirtualDiskFragmentationRequestType_Def not in ns0.QueryVirtualDiskFragmentation_Dec.__bases__: + bases = list(ns0.QueryVirtualDiskFragmentation_Dec.__bases__) + bases.insert(0, ns0.QueryVirtualDiskFragmentationRequestType_Def) + ns0.QueryVirtualDiskFragmentation_Dec.__bases__ = tuple(bases) + + ns0.QueryVirtualDiskFragmentationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVirtualDiskFragmentation_Dec_Holder" + + class QueryVirtualDiskFragmentationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVirtualDiskFragmentationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVirtualDiskFragmentationResponse_Dec.schema + TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVirtualDiskFragmentationResponse") + kw["aname"] = "_QueryVirtualDiskFragmentationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryVirtualDiskFragmentationResponse_Holder" + self.pyclass = Holder + + class DefragmentVirtualDisk_Dec(ElementDeclaration): + literal = "DefragmentVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DefragmentVirtualDisk") + kw["aname"] = "_DefragmentVirtualDisk" + if ns0.DefragmentVirtualDiskRequestType_Def not in ns0.DefragmentVirtualDisk_Dec.__bases__: + bases = list(ns0.DefragmentVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.DefragmentVirtualDiskRequestType_Def) + ns0.DefragmentVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.DefragmentVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DefragmentVirtualDisk_Dec_Holder" + + class DefragmentVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DefragmentVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DefragmentVirtualDiskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DefragmentVirtualDiskResponse") + kw["aname"] = "_DefragmentVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DefragmentVirtualDiskResponse_Holder" + self.pyclass = Holder + + class DefragmentVirtualDisk_Task_Dec(ElementDeclaration): + literal = "DefragmentVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DefragmentVirtualDisk_Task") + kw["aname"] = "_DefragmentVirtualDisk_Task" + if ns0.DefragmentVirtualDiskRequestType_Def not in ns0.DefragmentVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.DefragmentVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.DefragmentVirtualDiskRequestType_Def) + ns0.DefragmentVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.DefragmentVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DefragmentVirtualDisk_Task_Dec_Holder" + + class DefragmentVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DefragmentVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DefragmentVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DefragmentVirtualDisk_TaskResponse") + kw["aname"] = "_DefragmentVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DefragmentVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class ShrinkVirtualDisk_Dec(ElementDeclaration): + literal = "ShrinkVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ShrinkVirtualDisk") + kw["aname"] = "_ShrinkVirtualDisk" + if ns0.ShrinkVirtualDiskRequestType_Def not in ns0.ShrinkVirtualDisk_Dec.__bases__: + bases = list(ns0.ShrinkVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.ShrinkVirtualDiskRequestType_Def) + ns0.ShrinkVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.ShrinkVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ShrinkVirtualDisk_Dec_Holder" + + class ShrinkVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ShrinkVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ShrinkVirtualDiskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ShrinkVirtualDiskResponse") + kw["aname"] = "_ShrinkVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ShrinkVirtualDiskResponse_Holder" + self.pyclass = Holder + + class ShrinkVirtualDisk_Task_Dec(ElementDeclaration): + literal = "ShrinkVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ShrinkVirtualDisk_Task") + kw["aname"] = "_ShrinkVirtualDisk_Task" + if ns0.ShrinkVirtualDiskRequestType_Def not in ns0.ShrinkVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.ShrinkVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.ShrinkVirtualDiskRequestType_Def) + ns0.ShrinkVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.ShrinkVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ShrinkVirtualDisk_Task_Dec_Holder" + + class ShrinkVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ShrinkVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ShrinkVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ShrinkVirtualDisk_TaskResponse") + kw["aname"] = "_ShrinkVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ShrinkVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class InflateVirtualDisk_Dec(ElementDeclaration): + literal = "InflateVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InflateVirtualDisk") + kw["aname"] = "_InflateVirtualDisk" + if ns0.InflateVirtualDiskRequestType_Def not in ns0.InflateVirtualDisk_Dec.__bases__: + bases = list(ns0.InflateVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.InflateVirtualDiskRequestType_Def) + ns0.InflateVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.InflateVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InflateVirtualDisk_Dec_Holder" + + class InflateVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "InflateVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.InflateVirtualDiskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","InflateVirtualDiskResponse") + kw["aname"] = "_InflateVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "InflateVirtualDiskResponse_Holder" + self.pyclass = Holder + + class InflateVirtualDisk_Task_Dec(ElementDeclaration): + literal = "InflateVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InflateVirtualDisk_Task") + kw["aname"] = "_InflateVirtualDisk_Task" + if ns0.InflateVirtualDiskRequestType_Def not in ns0.InflateVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.InflateVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.InflateVirtualDiskRequestType_Def) + ns0.InflateVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.InflateVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InflateVirtualDisk_Task_Dec_Holder" + + class InflateVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "InflateVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.InflateVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","InflateVirtualDisk_TaskResponse") + kw["aname"] = "_InflateVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "InflateVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class EagerZeroVirtualDisk_Dec(ElementDeclaration): + literal = "EagerZeroVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EagerZeroVirtualDisk") + kw["aname"] = "_EagerZeroVirtualDisk" + if ns0.EagerZeroVirtualDiskRequestType_Def not in ns0.EagerZeroVirtualDisk_Dec.__bases__: + bases = list(ns0.EagerZeroVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.EagerZeroVirtualDiskRequestType_Def) + ns0.EagerZeroVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.EagerZeroVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EagerZeroVirtualDisk_Dec_Holder" + + class EagerZeroVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EagerZeroVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EagerZeroVirtualDiskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","EagerZeroVirtualDiskResponse") + kw["aname"] = "_EagerZeroVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "EagerZeroVirtualDiskResponse_Holder" + self.pyclass = Holder + + class EagerZeroVirtualDisk_Task_Dec(ElementDeclaration): + literal = "EagerZeroVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EagerZeroVirtualDisk_Task") + kw["aname"] = "_EagerZeroVirtualDisk_Task" + if ns0.EagerZeroVirtualDiskRequestType_Def not in ns0.EagerZeroVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.EagerZeroVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.EagerZeroVirtualDiskRequestType_Def) + ns0.EagerZeroVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.EagerZeroVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EagerZeroVirtualDisk_Task_Dec_Holder" + + class EagerZeroVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EagerZeroVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EagerZeroVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","EagerZeroVirtualDisk_TaskResponse") + kw["aname"] = "_EagerZeroVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "EagerZeroVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class ZeroFillVirtualDisk_Dec(ElementDeclaration): + literal = "ZeroFillVirtualDisk" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ZeroFillVirtualDisk") + kw["aname"] = "_ZeroFillVirtualDisk" + if ns0.ZeroFillVirtualDiskRequestType_Def not in ns0.ZeroFillVirtualDisk_Dec.__bases__: + bases = list(ns0.ZeroFillVirtualDisk_Dec.__bases__) + bases.insert(0, ns0.ZeroFillVirtualDiskRequestType_Def) + ns0.ZeroFillVirtualDisk_Dec.__bases__ = tuple(bases) + + ns0.ZeroFillVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ZeroFillVirtualDisk_Dec_Holder" + + class ZeroFillVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ZeroFillVirtualDiskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ZeroFillVirtualDiskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ZeroFillVirtualDiskResponse") + kw["aname"] = "_ZeroFillVirtualDiskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ZeroFillVirtualDiskResponse_Holder" + self.pyclass = Holder + + class ZeroFillVirtualDisk_Task_Dec(ElementDeclaration): + literal = "ZeroFillVirtualDisk_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ZeroFillVirtualDisk_Task") + kw["aname"] = "_ZeroFillVirtualDisk_Task" + if ns0.ZeroFillVirtualDiskRequestType_Def not in ns0.ZeroFillVirtualDisk_Task_Dec.__bases__: + bases = list(ns0.ZeroFillVirtualDisk_Task_Dec.__bases__) + bases.insert(0, ns0.ZeroFillVirtualDiskRequestType_Def) + ns0.ZeroFillVirtualDisk_Task_Dec.__bases__ = tuple(bases) + + ns0.ZeroFillVirtualDiskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ZeroFillVirtualDisk_Task_Dec_Holder" + + class ZeroFillVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ZeroFillVirtualDisk_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ZeroFillVirtualDisk_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ZeroFillVirtualDisk_TaskResponse") + kw["aname"] = "_ZeroFillVirtualDisk_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ZeroFillVirtualDisk_TaskResponse_Holder" + self.pyclass = Holder + + class SetVirtualDiskUuid_Dec(ElementDeclaration): + literal = "SetVirtualDiskUuid" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetVirtualDiskUuid") + kw["aname"] = "_SetVirtualDiskUuid" + if ns0.SetVirtualDiskUuidRequestType_Def not in ns0.SetVirtualDiskUuid_Dec.__bases__: + bases = list(ns0.SetVirtualDiskUuid_Dec.__bases__) + bases.insert(0, ns0.SetVirtualDiskUuidRequestType_Def) + ns0.SetVirtualDiskUuid_Dec.__bases__ = tuple(bases) + + ns0.SetVirtualDiskUuidRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetVirtualDiskUuid_Dec_Holder" + + class SetVirtualDiskUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetVirtualDiskUuidResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetVirtualDiskUuidResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetVirtualDiskUuidResponse") + kw["aname"] = "_SetVirtualDiskUuidResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetVirtualDiskUuidResponse_Holder" + self.pyclass = Holder + + class QueryVirtualDiskUuid_Dec(ElementDeclaration): + literal = "QueryVirtualDiskUuid" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVirtualDiskUuid") + kw["aname"] = "_QueryVirtualDiskUuid" + if ns0.QueryVirtualDiskUuidRequestType_Def not in ns0.QueryVirtualDiskUuid_Dec.__bases__: + bases = list(ns0.QueryVirtualDiskUuid_Dec.__bases__) + bases.insert(0, ns0.QueryVirtualDiskUuidRequestType_Def) + ns0.QueryVirtualDiskUuid_Dec.__bases__ = tuple(bases) + + ns0.QueryVirtualDiskUuidRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVirtualDiskUuid_Dec_Holder" + + class QueryVirtualDiskUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVirtualDiskUuidResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVirtualDiskUuidResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVirtualDiskUuidResponse") + kw["aname"] = "_QueryVirtualDiskUuidResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryVirtualDiskUuidResponse_Holder" + self.pyclass = Holder + + class QueryVirtualDiskGeometry_Dec(ElementDeclaration): + literal = "QueryVirtualDiskGeometry" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVirtualDiskGeometry") + kw["aname"] = "_QueryVirtualDiskGeometry" + if ns0.QueryVirtualDiskGeometryRequestType_Def not in ns0.QueryVirtualDiskGeometry_Dec.__bases__: + bases = list(ns0.QueryVirtualDiskGeometry_Dec.__bases__) + bases.insert(0, ns0.QueryVirtualDiskGeometryRequestType_Def) + ns0.QueryVirtualDiskGeometry_Dec.__bases__ = tuple(bases) + + ns0.QueryVirtualDiskGeometryRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVirtualDiskGeometry_Dec_Holder" + + class QueryVirtualDiskGeometryResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVirtualDiskGeometryResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVirtualDiskGeometryResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDiskDimensionsChs",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVirtualDiskGeometryResponse") + kw["aname"] = "_QueryVirtualDiskGeometryResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryVirtualDiskGeometryResponse_Holder" + self.pyclass = Holder + + class RefreshStorageInfo_Dec(ElementDeclaration): + literal = "RefreshStorageInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshStorageInfo") + kw["aname"] = "_RefreshStorageInfo" + if ns0.RefreshStorageInfoRequestType_Def not in ns0.RefreshStorageInfo_Dec.__bases__: + bases = list(ns0.RefreshStorageInfo_Dec.__bases__) + bases.insert(0, ns0.RefreshStorageInfoRequestType_Def) + ns0.RefreshStorageInfo_Dec.__bases__ = tuple(bases) + + ns0.RefreshStorageInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshStorageInfo_Dec_Holder" + + class RefreshStorageInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshStorageInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshStorageInfoResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshStorageInfoResponse") + kw["aname"] = "_RefreshStorageInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshStorageInfoResponse_Holder" + self.pyclass = Holder + + class CreateSnapshot_Dec(ElementDeclaration): + literal = "CreateSnapshot" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateSnapshot") + kw["aname"] = "_CreateSnapshot" + if ns0.CreateSnapshotRequestType_Def not in ns0.CreateSnapshot_Dec.__bases__: + bases = list(ns0.CreateSnapshot_Dec.__bases__) + bases.insert(0, ns0.CreateSnapshotRequestType_Def) + ns0.CreateSnapshot_Dec.__bases__ = tuple(bases) + + ns0.CreateSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateSnapshot_Dec_Holder" + + class CreateSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateSnapshotResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateSnapshotResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateSnapshotResponse") + kw["aname"] = "_CreateSnapshotResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateSnapshotResponse_Holder" + self.pyclass = Holder + + class CreateSnapshot_Task_Dec(ElementDeclaration): + literal = "CreateSnapshot_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateSnapshot_Task") + kw["aname"] = "_CreateSnapshot_Task" + if ns0.CreateSnapshotRequestType_Def not in ns0.CreateSnapshot_Task_Dec.__bases__: + bases = list(ns0.CreateSnapshot_Task_Dec.__bases__) + bases.insert(0, ns0.CreateSnapshotRequestType_Def) + ns0.CreateSnapshot_Task_Dec.__bases__ = tuple(bases) + + ns0.CreateSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateSnapshot_Task_Dec_Holder" + + class CreateSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateSnapshot_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateSnapshot_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateSnapshot_TaskResponse") + kw["aname"] = "_CreateSnapshot_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateSnapshot_TaskResponse_Holder" + self.pyclass = Holder + + class RevertToCurrentSnapshot_Dec(ElementDeclaration): + literal = "RevertToCurrentSnapshot" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RevertToCurrentSnapshot") + kw["aname"] = "_RevertToCurrentSnapshot" + if ns0.RevertToCurrentSnapshotRequestType_Def not in ns0.RevertToCurrentSnapshot_Dec.__bases__: + bases = list(ns0.RevertToCurrentSnapshot_Dec.__bases__) + bases.insert(0, ns0.RevertToCurrentSnapshotRequestType_Def) + ns0.RevertToCurrentSnapshot_Dec.__bases__ = tuple(bases) + + ns0.RevertToCurrentSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RevertToCurrentSnapshot_Dec_Holder" + + class RevertToCurrentSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RevertToCurrentSnapshotResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RevertToCurrentSnapshotResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RevertToCurrentSnapshotResponse") + kw["aname"] = "_RevertToCurrentSnapshotResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RevertToCurrentSnapshotResponse_Holder" + self.pyclass = Holder + + class RevertToCurrentSnapshot_Task_Dec(ElementDeclaration): + literal = "RevertToCurrentSnapshot_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RevertToCurrentSnapshot_Task") + kw["aname"] = "_RevertToCurrentSnapshot_Task" + if ns0.RevertToCurrentSnapshotRequestType_Def not in ns0.RevertToCurrentSnapshot_Task_Dec.__bases__: + bases = list(ns0.RevertToCurrentSnapshot_Task_Dec.__bases__) + bases.insert(0, ns0.RevertToCurrentSnapshotRequestType_Def) + ns0.RevertToCurrentSnapshot_Task_Dec.__bases__ = tuple(bases) + + ns0.RevertToCurrentSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RevertToCurrentSnapshot_Task_Dec_Holder" + + class RevertToCurrentSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RevertToCurrentSnapshot_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RevertToCurrentSnapshot_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RevertToCurrentSnapshot_TaskResponse") + kw["aname"] = "_RevertToCurrentSnapshot_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RevertToCurrentSnapshot_TaskResponse_Holder" + self.pyclass = Holder + + class RemoveAllSnapshots_Dec(ElementDeclaration): + literal = "RemoveAllSnapshots" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveAllSnapshots") + kw["aname"] = "_RemoveAllSnapshots" + if ns0.RemoveAllSnapshotsRequestType_Def not in ns0.RemoveAllSnapshots_Dec.__bases__: + bases = list(ns0.RemoveAllSnapshots_Dec.__bases__) + bases.insert(0, ns0.RemoveAllSnapshotsRequestType_Def) + ns0.RemoveAllSnapshots_Dec.__bases__ = tuple(bases) + + ns0.RemoveAllSnapshotsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveAllSnapshots_Dec_Holder" + + class RemoveAllSnapshotsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveAllSnapshotsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveAllSnapshotsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveAllSnapshotsResponse") + kw["aname"] = "_RemoveAllSnapshotsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveAllSnapshotsResponse_Holder" + self.pyclass = Holder + + class RemoveAllSnapshots_Task_Dec(ElementDeclaration): + literal = "RemoveAllSnapshots_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveAllSnapshots_Task") + kw["aname"] = "_RemoveAllSnapshots_Task" + if ns0.RemoveAllSnapshotsRequestType_Def not in ns0.RemoveAllSnapshots_Task_Dec.__bases__: + bases = list(ns0.RemoveAllSnapshots_Task_Dec.__bases__) + bases.insert(0, ns0.RemoveAllSnapshotsRequestType_Def) + ns0.RemoveAllSnapshots_Task_Dec.__bases__ = tuple(bases) + + ns0.RemoveAllSnapshotsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveAllSnapshots_Task_Dec_Holder" + + class RemoveAllSnapshots_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveAllSnapshots_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveAllSnapshots_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RemoveAllSnapshots_TaskResponse") + kw["aname"] = "_RemoveAllSnapshots_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RemoveAllSnapshots_TaskResponse_Holder" + self.pyclass = Holder + + class ReconfigVM_Dec(ElementDeclaration): + literal = "ReconfigVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigVM") + kw["aname"] = "_ReconfigVM" + if ns0.ReconfigVMRequestType_Def not in ns0.ReconfigVM_Dec.__bases__: + bases = list(ns0.ReconfigVM_Dec.__bases__) + bases.insert(0, ns0.ReconfigVMRequestType_Def) + ns0.ReconfigVM_Dec.__bases__ = tuple(bases) + + ns0.ReconfigVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigVM_Dec_Holder" + + class ReconfigVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigVMResponse") + kw["aname"] = "_ReconfigVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigVMResponse_Holder" + self.pyclass = Holder + + class ReconfigVM_Task_Dec(ElementDeclaration): + literal = "ReconfigVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigVM_Task") + kw["aname"] = "_ReconfigVM_Task" + if ns0.ReconfigVMRequestType_Def not in ns0.ReconfigVM_Task_Dec.__bases__: + bases = list(ns0.ReconfigVM_Task_Dec.__bases__) + bases.insert(0, ns0.ReconfigVMRequestType_Def) + ns0.ReconfigVM_Task_Dec.__bases__ = tuple(bases) + + ns0.ReconfigVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigVM_Task_Dec_Holder" + + class ReconfigVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReconfigVM_TaskResponse") + kw["aname"] = "_ReconfigVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ReconfigVM_TaskResponse_Holder" + self.pyclass = Holder + + class UpgradeVM_Dec(ElementDeclaration): + literal = "UpgradeVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpgradeVM") + kw["aname"] = "_UpgradeVM" + if ns0.UpgradeVMRequestType_Def not in ns0.UpgradeVM_Dec.__bases__: + bases = list(ns0.UpgradeVM_Dec.__bases__) + bases.insert(0, ns0.UpgradeVMRequestType_Def) + ns0.UpgradeVM_Dec.__bases__ = tuple(bases) + + ns0.UpgradeVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVM_Dec_Holder" + + class UpgradeVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpgradeVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpgradeVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpgradeVMResponse") + kw["aname"] = "_UpgradeVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpgradeVMResponse_Holder" + self.pyclass = Holder + + class UpgradeVM_Task_Dec(ElementDeclaration): + literal = "UpgradeVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpgradeVM_Task") + kw["aname"] = "_UpgradeVM_Task" + if ns0.UpgradeVMRequestType_Def not in ns0.UpgradeVM_Task_Dec.__bases__: + bases = list(ns0.UpgradeVM_Task_Dec.__bases__) + bases.insert(0, ns0.UpgradeVMRequestType_Def) + ns0.UpgradeVM_Task_Dec.__bases__ = tuple(bases) + + ns0.UpgradeVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVM_Task_Dec_Holder" + + class UpgradeVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpgradeVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpgradeVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UpgradeVM_TaskResponse") + kw["aname"] = "_UpgradeVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UpgradeVM_TaskResponse_Holder" + self.pyclass = Holder + + class ExtractOvfEnvironment_Dec(ElementDeclaration): + literal = "ExtractOvfEnvironment" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExtractOvfEnvironment") + kw["aname"] = "_ExtractOvfEnvironment" + if ns0.ExtractOvfEnvironmentRequestType_Def not in ns0.ExtractOvfEnvironment_Dec.__bases__: + bases = list(ns0.ExtractOvfEnvironment_Dec.__bases__) + bases.insert(0, ns0.ExtractOvfEnvironmentRequestType_Def) + ns0.ExtractOvfEnvironment_Dec.__bases__ = tuple(bases) + + ns0.ExtractOvfEnvironmentRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExtractOvfEnvironment_Dec_Holder" + + class ExtractOvfEnvironmentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExtractOvfEnvironmentResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExtractOvfEnvironmentResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ExtractOvfEnvironmentResponse") + kw["aname"] = "_ExtractOvfEnvironmentResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ExtractOvfEnvironmentResponse_Holder" + self.pyclass = Holder + + class PowerOnVM_Dec(ElementDeclaration): + literal = "PowerOnVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnVM") + kw["aname"] = "_PowerOnVM" + if ns0.PowerOnVMRequestType_Def not in ns0.PowerOnVM_Dec.__bases__: + bases = list(ns0.PowerOnVM_Dec.__bases__) + bases.insert(0, ns0.PowerOnVMRequestType_Def) + ns0.PowerOnVM_Dec.__bases__ = tuple(bases) + + ns0.PowerOnVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVM_Dec_Holder" + + class PowerOnVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOnVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOnVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PowerOnVMResponse") + kw["aname"] = "_PowerOnVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PowerOnVMResponse_Holder" + self.pyclass = Holder + + class PowerOnVM_Task_Dec(ElementDeclaration): + literal = "PowerOnVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnVM_Task") + kw["aname"] = "_PowerOnVM_Task" + if ns0.PowerOnVMRequestType_Def not in ns0.PowerOnVM_Task_Dec.__bases__: + bases = list(ns0.PowerOnVM_Task_Dec.__bases__) + bases.insert(0, ns0.PowerOnVMRequestType_Def) + ns0.PowerOnVM_Task_Dec.__bases__ = tuple(bases) + + ns0.PowerOnVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVM_Task_Dec_Holder" + + class PowerOnVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOnVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOnVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerOnVM_TaskResponse") + kw["aname"] = "_PowerOnVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerOnVM_TaskResponse_Holder" + self.pyclass = Holder + + class PowerOffVM_Dec(ElementDeclaration): + literal = "PowerOffVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOffVM") + kw["aname"] = "_PowerOffVM" + if ns0.PowerOffVMRequestType_Def not in ns0.PowerOffVM_Dec.__bases__: + bases = list(ns0.PowerOffVM_Dec.__bases__) + bases.insert(0, ns0.PowerOffVMRequestType_Def) + ns0.PowerOffVM_Dec.__bases__ = tuple(bases) + + ns0.PowerOffVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVM_Dec_Holder" + + class PowerOffVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOffVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOffVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PowerOffVMResponse") + kw["aname"] = "_PowerOffVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PowerOffVMResponse_Holder" + self.pyclass = Holder + + class PowerOffVM_Task_Dec(ElementDeclaration): + literal = "PowerOffVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOffVM_Task") + kw["aname"] = "_PowerOffVM_Task" + if ns0.PowerOffVMRequestType_Def not in ns0.PowerOffVM_Task_Dec.__bases__: + bases = list(ns0.PowerOffVM_Task_Dec.__bases__) + bases.insert(0, ns0.PowerOffVMRequestType_Def) + ns0.PowerOffVM_Task_Dec.__bases__ = tuple(bases) + + ns0.PowerOffVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVM_Task_Dec_Holder" + + class PowerOffVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PowerOffVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PowerOffVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PowerOffVM_TaskResponse") + kw["aname"] = "_PowerOffVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PowerOffVM_TaskResponse_Holder" + self.pyclass = Holder + + class SuspendVM_Dec(ElementDeclaration): + literal = "SuspendVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SuspendVM") + kw["aname"] = "_SuspendVM" + if ns0.SuspendVMRequestType_Def not in ns0.SuspendVM_Dec.__bases__: + bases = list(ns0.SuspendVM_Dec.__bases__) + bases.insert(0, ns0.SuspendVMRequestType_Def) + ns0.SuspendVM_Dec.__bases__ = tuple(bases) + + ns0.SuspendVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SuspendVM_Dec_Holder" + + class SuspendVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SuspendVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SuspendVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SuspendVMResponse") + kw["aname"] = "_SuspendVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SuspendVMResponse_Holder" + self.pyclass = Holder + + class SuspendVM_Task_Dec(ElementDeclaration): + literal = "SuspendVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SuspendVM_Task") + kw["aname"] = "_SuspendVM_Task" + if ns0.SuspendVMRequestType_Def not in ns0.SuspendVM_Task_Dec.__bases__: + bases = list(ns0.SuspendVM_Task_Dec.__bases__) + bases.insert(0, ns0.SuspendVMRequestType_Def) + ns0.SuspendVM_Task_Dec.__bases__ = tuple(bases) + + ns0.SuspendVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SuspendVM_Task_Dec_Holder" + + class SuspendVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SuspendVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SuspendVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","SuspendVM_TaskResponse") + kw["aname"] = "_SuspendVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "SuspendVM_TaskResponse_Holder" + self.pyclass = Holder + + class ResetVM_Dec(ElementDeclaration): + literal = "ResetVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetVM") + kw["aname"] = "_ResetVM" + if ns0.ResetVMRequestType_Def not in ns0.ResetVM_Dec.__bases__: + bases = list(ns0.ResetVM_Dec.__bases__) + bases.insert(0, ns0.ResetVMRequestType_Def) + ns0.ResetVM_Dec.__bases__ = tuple(bases) + + ns0.ResetVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetVM_Dec_Holder" + + class ResetVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetVMResponse") + kw["aname"] = "_ResetVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetVMResponse_Holder" + self.pyclass = Holder + + class ResetVM_Task_Dec(ElementDeclaration): + literal = "ResetVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetVM_Task") + kw["aname"] = "_ResetVM_Task" + if ns0.ResetVMRequestType_Def not in ns0.ResetVM_Task_Dec.__bases__: + bases = list(ns0.ResetVM_Task_Dec.__bases__) + bases.insert(0, ns0.ResetVMRequestType_Def) + ns0.ResetVM_Task_Dec.__bases__ = tuple(bases) + + ns0.ResetVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetVM_Task_Dec_Holder" + + class ResetVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ResetVM_TaskResponse") + kw["aname"] = "_ResetVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ResetVM_TaskResponse_Holder" + self.pyclass = Holder + + class ShutdownGuest_Dec(ElementDeclaration): + literal = "ShutdownGuest" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ShutdownGuest") + kw["aname"] = "_ShutdownGuest" + if ns0.ShutdownGuestRequestType_Def not in ns0.ShutdownGuest_Dec.__bases__: + bases = list(ns0.ShutdownGuest_Dec.__bases__) + bases.insert(0, ns0.ShutdownGuestRequestType_Def) + ns0.ShutdownGuest_Dec.__bases__ = tuple(bases) + + ns0.ShutdownGuestRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ShutdownGuest_Dec_Holder" + + class ShutdownGuestResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ShutdownGuestResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ShutdownGuestResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ShutdownGuestResponse") + kw["aname"] = "_ShutdownGuestResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ShutdownGuestResponse_Holder" + self.pyclass = Holder + + class RebootGuest_Dec(ElementDeclaration): + literal = "RebootGuest" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RebootGuest") + kw["aname"] = "_RebootGuest" + if ns0.RebootGuestRequestType_Def not in ns0.RebootGuest_Dec.__bases__: + bases = list(ns0.RebootGuest_Dec.__bases__) + bases.insert(0, ns0.RebootGuestRequestType_Def) + ns0.RebootGuest_Dec.__bases__ = tuple(bases) + + ns0.RebootGuestRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RebootGuest_Dec_Holder" + + class RebootGuestResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RebootGuestResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RebootGuestResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RebootGuestResponse") + kw["aname"] = "_RebootGuestResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RebootGuestResponse_Holder" + self.pyclass = Holder + + class StandbyGuest_Dec(ElementDeclaration): + literal = "StandbyGuest" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StandbyGuest") + kw["aname"] = "_StandbyGuest" + if ns0.StandbyGuestRequestType_Def not in ns0.StandbyGuest_Dec.__bases__: + bases = list(ns0.StandbyGuest_Dec.__bases__) + bases.insert(0, ns0.StandbyGuestRequestType_Def) + ns0.StandbyGuest_Dec.__bases__ = tuple(bases) + + ns0.StandbyGuestRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StandbyGuest_Dec_Holder" + + class StandbyGuestResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StandbyGuestResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StandbyGuestResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","StandbyGuestResponse") + kw["aname"] = "_StandbyGuestResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "StandbyGuestResponse_Holder" + self.pyclass = Holder + + class AnswerVM_Dec(ElementDeclaration): + literal = "AnswerVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AnswerVM") + kw["aname"] = "_AnswerVM" + if ns0.AnswerVMRequestType_Def not in ns0.AnswerVM_Dec.__bases__: + bases = list(ns0.AnswerVM_Dec.__bases__) + bases.insert(0, ns0.AnswerVMRequestType_Def) + ns0.AnswerVM_Dec.__bases__ = tuple(bases) + + ns0.AnswerVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AnswerVM_Dec_Holder" + + class AnswerVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AnswerVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AnswerVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AnswerVMResponse") + kw["aname"] = "_AnswerVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AnswerVMResponse_Holder" + self.pyclass = Holder + + class CustomizeVM_Dec(ElementDeclaration): + literal = "CustomizeVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CustomizeVM") + kw["aname"] = "_CustomizeVM" + if ns0.CustomizeVMRequestType_Def not in ns0.CustomizeVM_Dec.__bases__: + bases = list(ns0.CustomizeVM_Dec.__bases__) + bases.insert(0, ns0.CustomizeVMRequestType_Def) + ns0.CustomizeVM_Dec.__bases__ = tuple(bases) + + ns0.CustomizeVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CustomizeVM_Dec_Holder" + + class CustomizeVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CustomizeVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CustomizeVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CustomizeVMResponse") + kw["aname"] = "_CustomizeVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CustomizeVMResponse_Holder" + self.pyclass = Holder + + class CustomizeVM_Task_Dec(ElementDeclaration): + literal = "CustomizeVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CustomizeVM_Task") + kw["aname"] = "_CustomizeVM_Task" + if ns0.CustomizeVMRequestType_Def not in ns0.CustomizeVM_Task_Dec.__bases__: + bases = list(ns0.CustomizeVM_Task_Dec.__bases__) + bases.insert(0, ns0.CustomizeVMRequestType_Def) + ns0.CustomizeVM_Task_Dec.__bases__ = tuple(bases) + + ns0.CustomizeVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CustomizeVM_Task_Dec_Holder" + + class CustomizeVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CustomizeVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CustomizeVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CustomizeVM_TaskResponse") + kw["aname"] = "_CustomizeVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CustomizeVM_TaskResponse_Holder" + self.pyclass = Holder + + class CheckCustomizationSpec_Dec(ElementDeclaration): + literal = "CheckCustomizationSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckCustomizationSpec") + kw["aname"] = "_CheckCustomizationSpec" + if ns0.CheckCustomizationSpecRequestType_Def not in ns0.CheckCustomizationSpec_Dec.__bases__: + bases = list(ns0.CheckCustomizationSpec_Dec.__bases__) + bases.insert(0, ns0.CheckCustomizationSpecRequestType_Def) + ns0.CheckCustomizationSpec_Dec.__bases__ = tuple(bases) + + ns0.CheckCustomizationSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckCustomizationSpec_Dec_Holder" + + class CheckCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckCustomizationSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckCustomizationSpecResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CheckCustomizationSpecResponse") + kw["aname"] = "_CheckCustomizationSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CheckCustomizationSpecResponse_Holder" + self.pyclass = Holder + + class MigrateVM_Dec(ElementDeclaration): + literal = "MigrateVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MigrateVM") + kw["aname"] = "_MigrateVM" + if ns0.MigrateVMRequestType_Def not in ns0.MigrateVM_Dec.__bases__: + bases = list(ns0.MigrateVM_Dec.__bases__) + bases.insert(0, ns0.MigrateVMRequestType_Def) + ns0.MigrateVM_Dec.__bases__ = tuple(bases) + + ns0.MigrateVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MigrateVM_Dec_Holder" + + class MigrateVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MigrateVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MigrateVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MigrateVMResponse") + kw["aname"] = "_MigrateVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MigrateVMResponse_Holder" + self.pyclass = Holder + + class MigrateVM_Task_Dec(ElementDeclaration): + literal = "MigrateVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MigrateVM_Task") + kw["aname"] = "_MigrateVM_Task" + if ns0.MigrateVMRequestType_Def not in ns0.MigrateVM_Task_Dec.__bases__: + bases = list(ns0.MigrateVM_Task_Dec.__bases__) + bases.insert(0, ns0.MigrateVMRequestType_Def) + ns0.MigrateVM_Task_Dec.__bases__ = tuple(bases) + + ns0.MigrateVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MigrateVM_Task_Dec_Holder" + + class MigrateVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MigrateVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MigrateVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MigrateVM_TaskResponse") + kw["aname"] = "_MigrateVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MigrateVM_TaskResponse_Holder" + self.pyclass = Holder + + class RelocateVM_Dec(ElementDeclaration): + literal = "RelocateVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RelocateVM") + kw["aname"] = "_RelocateVM" + if ns0.RelocateVMRequestType_Def not in ns0.RelocateVM_Dec.__bases__: + bases = list(ns0.RelocateVM_Dec.__bases__) + bases.insert(0, ns0.RelocateVMRequestType_Def) + ns0.RelocateVM_Dec.__bases__ = tuple(bases) + + ns0.RelocateVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RelocateVM_Dec_Holder" + + class RelocateVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RelocateVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RelocateVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RelocateVMResponse") + kw["aname"] = "_RelocateVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RelocateVMResponse_Holder" + self.pyclass = Holder + + class RelocateVM_Task_Dec(ElementDeclaration): + literal = "RelocateVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RelocateVM_Task") + kw["aname"] = "_RelocateVM_Task" + if ns0.RelocateVMRequestType_Def not in ns0.RelocateVM_Task_Dec.__bases__: + bases = list(ns0.RelocateVM_Task_Dec.__bases__) + bases.insert(0, ns0.RelocateVMRequestType_Def) + ns0.RelocateVM_Task_Dec.__bases__ = tuple(bases) + + ns0.RelocateVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RelocateVM_Task_Dec_Holder" + + class RelocateVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RelocateVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RelocateVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RelocateVM_TaskResponse") + kw["aname"] = "_RelocateVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RelocateVM_TaskResponse_Holder" + self.pyclass = Holder + + class CloneVM_Dec(ElementDeclaration): + literal = "CloneVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CloneVM") + kw["aname"] = "_CloneVM" + if ns0.CloneVMRequestType_Def not in ns0.CloneVM_Dec.__bases__: + bases = list(ns0.CloneVM_Dec.__bases__) + bases.insert(0, ns0.CloneVMRequestType_Def) + ns0.CloneVM_Dec.__bases__ = tuple(bases) + + ns0.CloneVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CloneVM_Dec_Holder" + + class CloneVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CloneVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CloneVMResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CloneVMResponse") + kw["aname"] = "_CloneVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CloneVMResponse_Holder" + self.pyclass = Holder + + class CloneVM_Task_Dec(ElementDeclaration): + literal = "CloneVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CloneVM_Task") + kw["aname"] = "_CloneVM_Task" + if ns0.CloneVMRequestType_Def not in ns0.CloneVM_Task_Dec.__bases__: + bases = list(ns0.CloneVM_Task_Dec.__bases__) + bases.insert(0, ns0.CloneVMRequestType_Def) + ns0.CloneVM_Task_Dec.__bases__ = tuple(bases) + + ns0.CloneVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CloneVM_Task_Dec_Holder" + + class CloneVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CloneVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CloneVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CloneVM_TaskResponse") + kw["aname"] = "_CloneVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CloneVM_TaskResponse_Holder" + self.pyclass = Holder + + class ExportVm_Dec(ElementDeclaration): + literal = "ExportVm" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExportVm") + kw["aname"] = "_ExportVm" + if ns0.ExportVmRequestType_Def not in ns0.ExportVm_Dec.__bases__: + bases = list(ns0.ExportVm_Dec.__bases__) + bases.insert(0, ns0.ExportVmRequestType_Def) + ns0.ExportVm_Dec.__bases__ = tuple(bases) + + ns0.ExportVmRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExportVm_Dec_Holder" + + class ExportVmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExportVmResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExportVmResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ExportVmResponse") + kw["aname"] = "_ExportVmResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ExportVmResponse_Holder" + self.pyclass = Holder + + class MarkAsTemplate_Dec(ElementDeclaration): + literal = "MarkAsTemplate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MarkAsTemplate") + kw["aname"] = "_MarkAsTemplate" + if ns0.MarkAsTemplateRequestType_Def not in ns0.MarkAsTemplate_Dec.__bases__: + bases = list(ns0.MarkAsTemplate_Dec.__bases__) + bases.insert(0, ns0.MarkAsTemplateRequestType_Def) + ns0.MarkAsTemplate_Dec.__bases__ = tuple(bases) + + ns0.MarkAsTemplateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MarkAsTemplate_Dec_Holder" + + class MarkAsTemplateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MarkAsTemplateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MarkAsTemplateResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MarkAsTemplateResponse") + kw["aname"] = "_MarkAsTemplateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MarkAsTemplateResponse_Holder" + self.pyclass = Holder + + class MarkAsVirtualMachine_Dec(ElementDeclaration): + literal = "MarkAsVirtualMachine" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MarkAsVirtualMachine") + kw["aname"] = "_MarkAsVirtualMachine" + if ns0.MarkAsVirtualMachineRequestType_Def not in ns0.MarkAsVirtualMachine_Dec.__bases__: + bases = list(ns0.MarkAsVirtualMachine_Dec.__bases__) + bases.insert(0, ns0.MarkAsVirtualMachineRequestType_Def) + ns0.MarkAsVirtualMachine_Dec.__bases__ = tuple(bases) + + ns0.MarkAsVirtualMachineRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MarkAsVirtualMachine_Dec_Holder" + + class MarkAsVirtualMachineResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MarkAsVirtualMachineResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MarkAsVirtualMachineResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MarkAsVirtualMachineResponse") + kw["aname"] = "_MarkAsVirtualMachineResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MarkAsVirtualMachineResponse_Holder" + self.pyclass = Holder + + class UnregisterVM_Dec(ElementDeclaration): + literal = "UnregisterVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnregisterVM") + kw["aname"] = "_UnregisterVM" + if ns0.UnregisterVMRequestType_Def not in ns0.UnregisterVM_Dec.__bases__: + bases = list(ns0.UnregisterVM_Dec.__bases__) + bases.insert(0, ns0.UnregisterVMRequestType_Def) + ns0.UnregisterVM_Dec.__bases__ = tuple(bases) + + ns0.UnregisterVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnregisterVM_Dec_Holder" + + class UnregisterVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UnregisterVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UnregisterVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UnregisterVMResponse") + kw["aname"] = "_UnregisterVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UnregisterVMResponse_Holder" + self.pyclass = Holder + + class ResetGuestInformation_Dec(ElementDeclaration): + literal = "ResetGuestInformation" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetGuestInformation") + kw["aname"] = "_ResetGuestInformation" + if ns0.ResetGuestInformationRequestType_Def not in ns0.ResetGuestInformation_Dec.__bases__: + bases = list(ns0.ResetGuestInformation_Dec.__bases__) + bases.insert(0, ns0.ResetGuestInformationRequestType_Def) + ns0.ResetGuestInformation_Dec.__bases__ = tuple(bases) + + ns0.ResetGuestInformationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetGuestInformation_Dec_Holder" + + class ResetGuestInformationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetGuestInformationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetGuestInformationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetGuestInformationResponse") + kw["aname"] = "_ResetGuestInformationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetGuestInformationResponse_Holder" + self.pyclass = Holder + + class MountToolsInstaller_Dec(ElementDeclaration): + literal = "MountToolsInstaller" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MountToolsInstaller") + kw["aname"] = "_MountToolsInstaller" + if ns0.MountToolsInstallerRequestType_Def not in ns0.MountToolsInstaller_Dec.__bases__: + bases = list(ns0.MountToolsInstaller_Dec.__bases__) + bases.insert(0, ns0.MountToolsInstallerRequestType_Def) + ns0.MountToolsInstaller_Dec.__bases__ = tuple(bases) + + ns0.MountToolsInstallerRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MountToolsInstaller_Dec_Holder" + + class MountToolsInstallerResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MountToolsInstallerResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MountToolsInstallerResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MountToolsInstallerResponse") + kw["aname"] = "_MountToolsInstallerResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MountToolsInstallerResponse_Holder" + self.pyclass = Holder + + class UnmountToolsInstaller_Dec(ElementDeclaration): + literal = "UnmountToolsInstaller" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnmountToolsInstaller") + kw["aname"] = "_UnmountToolsInstaller" + if ns0.UnmountToolsInstallerRequestType_Def not in ns0.UnmountToolsInstaller_Dec.__bases__: + bases = list(ns0.UnmountToolsInstaller_Dec.__bases__) + bases.insert(0, ns0.UnmountToolsInstallerRequestType_Def) + ns0.UnmountToolsInstaller_Dec.__bases__ = tuple(bases) + + ns0.UnmountToolsInstallerRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnmountToolsInstaller_Dec_Holder" + + class UnmountToolsInstallerResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UnmountToolsInstallerResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UnmountToolsInstallerResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UnmountToolsInstallerResponse") + kw["aname"] = "_UnmountToolsInstallerResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UnmountToolsInstallerResponse_Holder" + self.pyclass = Holder + + class UpgradeTools_Dec(ElementDeclaration): + literal = "UpgradeTools" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpgradeTools") + kw["aname"] = "_UpgradeTools" + if ns0.UpgradeToolsRequestType_Def not in ns0.UpgradeTools_Dec.__bases__: + bases = list(ns0.UpgradeTools_Dec.__bases__) + bases.insert(0, ns0.UpgradeToolsRequestType_Def) + ns0.UpgradeTools_Dec.__bases__ = tuple(bases) + + ns0.UpgradeToolsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpgradeTools_Dec_Holder" + + class UpgradeToolsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpgradeToolsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpgradeToolsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpgradeToolsResponse") + kw["aname"] = "_UpgradeToolsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpgradeToolsResponse_Holder" + self.pyclass = Holder + + class UpgradeTools_Task_Dec(ElementDeclaration): + literal = "UpgradeTools_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpgradeTools_Task") + kw["aname"] = "_UpgradeTools_Task" + if ns0.UpgradeToolsRequestType_Def not in ns0.UpgradeTools_Task_Dec.__bases__: + bases = list(ns0.UpgradeTools_Task_Dec.__bases__) + bases.insert(0, ns0.UpgradeToolsRequestType_Def) + ns0.UpgradeTools_Task_Dec.__bases__ = tuple(bases) + + ns0.UpgradeToolsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpgradeTools_Task_Dec_Holder" + + class UpgradeTools_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpgradeTools_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpgradeTools_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UpgradeTools_TaskResponse") + kw["aname"] = "_UpgradeTools_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UpgradeTools_TaskResponse_Holder" + self.pyclass = Holder + + class AcquireMksTicket_Dec(ElementDeclaration): + literal = "AcquireMksTicket" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AcquireMksTicket") + kw["aname"] = "_AcquireMksTicket" + if ns0.AcquireMksTicketRequestType_Def not in ns0.AcquireMksTicket_Dec.__bases__: + bases = list(ns0.AcquireMksTicket_Dec.__bases__) + bases.insert(0, ns0.AcquireMksTicketRequestType_Def) + ns0.AcquireMksTicket_Dec.__bases__ = tuple(bases) + + ns0.AcquireMksTicketRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AcquireMksTicket_Dec_Holder" + + class AcquireMksTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AcquireMksTicketResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AcquireMksTicketResponse_Dec.schema + TClist = [GTD("urn:vim25","VirtualMachineMksTicket",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AcquireMksTicketResponse") + kw["aname"] = "_AcquireMksTicketResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AcquireMksTicketResponse_Holder" + self.pyclass = Holder + + class SetScreenResolution_Dec(ElementDeclaration): + literal = "SetScreenResolution" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetScreenResolution") + kw["aname"] = "_SetScreenResolution" + if ns0.SetScreenResolutionRequestType_Def not in ns0.SetScreenResolution_Dec.__bases__: + bases = list(ns0.SetScreenResolution_Dec.__bases__) + bases.insert(0, ns0.SetScreenResolutionRequestType_Def) + ns0.SetScreenResolution_Dec.__bases__ = tuple(bases) + + ns0.SetScreenResolutionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetScreenResolution_Dec_Holder" + + class SetScreenResolutionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetScreenResolutionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetScreenResolutionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetScreenResolutionResponse") + kw["aname"] = "_SetScreenResolutionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetScreenResolutionResponse_Holder" + self.pyclass = Holder + + class DefragmentAllDisks_Dec(ElementDeclaration): + literal = "DefragmentAllDisks" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DefragmentAllDisks") + kw["aname"] = "_DefragmentAllDisks" + if ns0.DefragmentAllDisksRequestType_Def not in ns0.DefragmentAllDisks_Dec.__bases__: + bases = list(ns0.DefragmentAllDisks_Dec.__bases__) + bases.insert(0, ns0.DefragmentAllDisksRequestType_Def) + ns0.DefragmentAllDisks_Dec.__bases__ = tuple(bases) + + ns0.DefragmentAllDisksRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DefragmentAllDisks_Dec_Holder" + + class DefragmentAllDisksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DefragmentAllDisksResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DefragmentAllDisksResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DefragmentAllDisksResponse") + kw["aname"] = "_DefragmentAllDisksResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DefragmentAllDisksResponse_Holder" + self.pyclass = Holder + + class CreateSecondaryVM_Dec(ElementDeclaration): + literal = "CreateSecondaryVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateSecondaryVM") + kw["aname"] = "_CreateSecondaryVM" + if ns0.CreateSecondaryVMRequestType_Def not in ns0.CreateSecondaryVM_Dec.__bases__: + bases = list(ns0.CreateSecondaryVM_Dec.__bases__) + bases.insert(0, ns0.CreateSecondaryVMRequestType_Def) + ns0.CreateSecondaryVM_Dec.__bases__ = tuple(bases) + + ns0.CreateSecondaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateSecondaryVM_Dec_Holder" + + class CreateSecondaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateSecondaryVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateSecondaryVMResponse_Dec.schema + TClist = [GTD("urn:vim25","FaultToleranceSecondaryOpResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateSecondaryVMResponse") + kw["aname"] = "_CreateSecondaryVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateSecondaryVMResponse_Holder" + self.pyclass = Holder + + class CreateSecondaryVM_Task_Dec(ElementDeclaration): + literal = "CreateSecondaryVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateSecondaryVM_Task") + kw["aname"] = "_CreateSecondaryVM_Task" + if ns0.CreateSecondaryVMRequestType_Def not in ns0.CreateSecondaryVM_Task_Dec.__bases__: + bases = list(ns0.CreateSecondaryVM_Task_Dec.__bases__) + bases.insert(0, ns0.CreateSecondaryVMRequestType_Def) + ns0.CreateSecondaryVM_Task_Dec.__bases__ = tuple(bases) + + ns0.CreateSecondaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateSecondaryVM_Task_Dec_Holder" + + class CreateSecondaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateSecondaryVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateSecondaryVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateSecondaryVM_TaskResponse") + kw["aname"] = "_CreateSecondaryVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateSecondaryVM_TaskResponse_Holder" + self.pyclass = Holder + + class TurnOffFaultToleranceForVM_Dec(ElementDeclaration): + literal = "TurnOffFaultToleranceForVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVM") + kw["aname"] = "_TurnOffFaultToleranceForVM" + if ns0.TurnOffFaultToleranceForVMRequestType_Def not in ns0.TurnOffFaultToleranceForVM_Dec.__bases__: + bases = list(ns0.TurnOffFaultToleranceForVM_Dec.__bases__) + bases.insert(0, ns0.TurnOffFaultToleranceForVMRequestType_Def) + ns0.TurnOffFaultToleranceForVM_Dec.__bases__ = tuple(bases) + + ns0.TurnOffFaultToleranceForVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TurnOffFaultToleranceForVM_Dec_Holder" + + class TurnOffFaultToleranceForVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "TurnOffFaultToleranceForVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.TurnOffFaultToleranceForVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVMResponse") + kw["aname"] = "_TurnOffFaultToleranceForVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "TurnOffFaultToleranceForVMResponse_Holder" + self.pyclass = Holder + + class TurnOffFaultToleranceForVM_Task_Dec(ElementDeclaration): + literal = "TurnOffFaultToleranceForVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVM_Task") + kw["aname"] = "_TurnOffFaultToleranceForVM_Task" + if ns0.TurnOffFaultToleranceForVMRequestType_Def not in ns0.TurnOffFaultToleranceForVM_Task_Dec.__bases__: + bases = list(ns0.TurnOffFaultToleranceForVM_Task_Dec.__bases__) + bases.insert(0, ns0.TurnOffFaultToleranceForVMRequestType_Def) + ns0.TurnOffFaultToleranceForVM_Task_Dec.__bases__ = tuple(bases) + + ns0.TurnOffFaultToleranceForVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TurnOffFaultToleranceForVM_Task_Dec_Holder" + + class TurnOffFaultToleranceForVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "TurnOffFaultToleranceForVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.TurnOffFaultToleranceForVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVM_TaskResponse") + kw["aname"] = "_TurnOffFaultToleranceForVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "TurnOffFaultToleranceForVM_TaskResponse_Holder" + self.pyclass = Holder + + class MakePrimaryVM_Dec(ElementDeclaration): + literal = "MakePrimaryVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MakePrimaryVM") + kw["aname"] = "_MakePrimaryVM" + if ns0.MakePrimaryVMRequestType_Def not in ns0.MakePrimaryVM_Dec.__bases__: + bases = list(ns0.MakePrimaryVM_Dec.__bases__) + bases.insert(0, ns0.MakePrimaryVMRequestType_Def) + ns0.MakePrimaryVM_Dec.__bases__ = tuple(bases) + + ns0.MakePrimaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MakePrimaryVM_Dec_Holder" + + class MakePrimaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MakePrimaryVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MakePrimaryVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","MakePrimaryVMResponse") + kw["aname"] = "_MakePrimaryVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "MakePrimaryVMResponse_Holder" + self.pyclass = Holder + + class MakePrimaryVM_Task_Dec(ElementDeclaration): + literal = "MakePrimaryVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MakePrimaryVM_Task") + kw["aname"] = "_MakePrimaryVM_Task" + if ns0.MakePrimaryVMRequestType_Def not in ns0.MakePrimaryVM_Task_Dec.__bases__: + bases = list(ns0.MakePrimaryVM_Task_Dec.__bases__) + bases.insert(0, ns0.MakePrimaryVMRequestType_Def) + ns0.MakePrimaryVM_Task_Dec.__bases__ = tuple(bases) + + ns0.MakePrimaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MakePrimaryVM_Task_Dec_Holder" + + class MakePrimaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "MakePrimaryVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.MakePrimaryVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","MakePrimaryVM_TaskResponse") + kw["aname"] = "_MakePrimaryVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "MakePrimaryVM_TaskResponse_Holder" + self.pyclass = Holder + + class TerminateFaultTolerantVM_Dec(ElementDeclaration): + literal = "TerminateFaultTolerantVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TerminateFaultTolerantVM") + kw["aname"] = "_TerminateFaultTolerantVM" + if ns0.TerminateFaultTolerantVMRequestType_Def not in ns0.TerminateFaultTolerantVM_Dec.__bases__: + bases = list(ns0.TerminateFaultTolerantVM_Dec.__bases__) + bases.insert(0, ns0.TerminateFaultTolerantVMRequestType_Def) + ns0.TerminateFaultTolerantVM_Dec.__bases__ = tuple(bases) + + ns0.TerminateFaultTolerantVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TerminateFaultTolerantVM_Dec_Holder" + + class TerminateFaultTolerantVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "TerminateFaultTolerantVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.TerminateFaultTolerantVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","TerminateFaultTolerantVMResponse") + kw["aname"] = "_TerminateFaultTolerantVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "TerminateFaultTolerantVMResponse_Holder" + self.pyclass = Holder + + class TerminateFaultTolerantVM_Task_Dec(ElementDeclaration): + literal = "TerminateFaultTolerantVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TerminateFaultTolerantVM_Task") + kw["aname"] = "_TerminateFaultTolerantVM_Task" + if ns0.TerminateFaultTolerantVMRequestType_Def not in ns0.TerminateFaultTolerantVM_Task_Dec.__bases__: + bases = list(ns0.TerminateFaultTolerantVM_Task_Dec.__bases__) + bases.insert(0, ns0.TerminateFaultTolerantVMRequestType_Def) + ns0.TerminateFaultTolerantVM_Task_Dec.__bases__ = tuple(bases) + + ns0.TerminateFaultTolerantVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TerminateFaultTolerantVM_Task_Dec_Holder" + + class TerminateFaultTolerantVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "TerminateFaultTolerantVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.TerminateFaultTolerantVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","TerminateFaultTolerantVM_TaskResponse") + kw["aname"] = "_TerminateFaultTolerantVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "TerminateFaultTolerantVM_TaskResponse_Holder" + self.pyclass = Holder + + class DisableSecondaryVM_Dec(ElementDeclaration): + literal = "DisableSecondaryVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisableSecondaryVM") + kw["aname"] = "_DisableSecondaryVM" + if ns0.DisableSecondaryVMRequestType_Def not in ns0.DisableSecondaryVM_Dec.__bases__: + bases = list(ns0.DisableSecondaryVM_Dec.__bases__) + bases.insert(0, ns0.DisableSecondaryVMRequestType_Def) + ns0.DisableSecondaryVM_Dec.__bases__ = tuple(bases) + + ns0.DisableSecondaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisableSecondaryVM_Dec_Holder" + + class DisableSecondaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisableSecondaryVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisableSecondaryVMResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DisableSecondaryVMResponse") + kw["aname"] = "_DisableSecondaryVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DisableSecondaryVMResponse_Holder" + self.pyclass = Holder + + class DisableSecondaryVM_Task_Dec(ElementDeclaration): + literal = "DisableSecondaryVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisableSecondaryVM_Task") + kw["aname"] = "_DisableSecondaryVM_Task" + if ns0.DisableSecondaryVMRequestType_Def not in ns0.DisableSecondaryVM_Task_Dec.__bases__: + bases = list(ns0.DisableSecondaryVM_Task_Dec.__bases__) + bases.insert(0, ns0.DisableSecondaryVMRequestType_Def) + ns0.DisableSecondaryVM_Task_Dec.__bases__ = tuple(bases) + + ns0.DisableSecondaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisableSecondaryVM_Task_Dec_Holder" + + class DisableSecondaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisableSecondaryVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisableSecondaryVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DisableSecondaryVM_TaskResponse") + kw["aname"] = "_DisableSecondaryVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DisableSecondaryVM_TaskResponse_Holder" + self.pyclass = Holder + + class EnableSecondaryVM_Dec(ElementDeclaration): + literal = "EnableSecondaryVM" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnableSecondaryVM") + kw["aname"] = "_EnableSecondaryVM" + if ns0.EnableSecondaryVMRequestType_Def not in ns0.EnableSecondaryVM_Dec.__bases__: + bases = list(ns0.EnableSecondaryVM_Dec.__bases__) + bases.insert(0, ns0.EnableSecondaryVMRequestType_Def) + ns0.EnableSecondaryVM_Dec.__bases__ = tuple(bases) + + ns0.EnableSecondaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnableSecondaryVM_Dec_Holder" + + class EnableSecondaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnableSecondaryVMResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnableSecondaryVMResponse_Dec.schema + TClist = [GTD("urn:vim25","FaultToleranceSecondaryOpResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","EnableSecondaryVMResponse") + kw["aname"] = "_EnableSecondaryVMResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "EnableSecondaryVMResponse_Holder" + self.pyclass = Holder + + class EnableSecondaryVM_Task_Dec(ElementDeclaration): + literal = "EnableSecondaryVM_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnableSecondaryVM_Task") + kw["aname"] = "_EnableSecondaryVM_Task" + if ns0.EnableSecondaryVMRequestType_Def not in ns0.EnableSecondaryVM_Task_Dec.__bases__: + bases = list(ns0.EnableSecondaryVM_Task_Dec.__bases__) + bases.insert(0, ns0.EnableSecondaryVMRequestType_Def) + ns0.EnableSecondaryVM_Task_Dec.__bases__ = tuple(bases) + + ns0.EnableSecondaryVMRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnableSecondaryVM_Task_Dec_Holder" + + class EnableSecondaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnableSecondaryVM_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnableSecondaryVM_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","EnableSecondaryVM_TaskResponse") + kw["aname"] = "_EnableSecondaryVM_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "EnableSecondaryVM_TaskResponse_Holder" + self.pyclass = Holder + + class SetDisplayTopology_Dec(ElementDeclaration): + literal = "SetDisplayTopology" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetDisplayTopology") + kw["aname"] = "_SetDisplayTopology" + if ns0.SetDisplayTopologyRequestType_Def not in ns0.SetDisplayTopology_Dec.__bases__: + bases = list(ns0.SetDisplayTopology_Dec.__bases__) + bases.insert(0, ns0.SetDisplayTopologyRequestType_Def) + ns0.SetDisplayTopology_Dec.__bases__ = tuple(bases) + + ns0.SetDisplayTopologyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetDisplayTopology_Dec_Holder" + + class SetDisplayTopologyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetDisplayTopologyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetDisplayTopologyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetDisplayTopologyResponse") + kw["aname"] = "_SetDisplayTopologyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetDisplayTopologyResponse_Holder" + self.pyclass = Holder + + class StartRecording_Dec(ElementDeclaration): + literal = "StartRecording" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StartRecording") + kw["aname"] = "_StartRecording" + if ns0.StartRecordingRequestType_Def not in ns0.StartRecording_Dec.__bases__: + bases = list(ns0.StartRecording_Dec.__bases__) + bases.insert(0, ns0.StartRecordingRequestType_Def) + ns0.StartRecording_Dec.__bases__ = tuple(bases) + + ns0.StartRecordingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StartRecording_Dec_Holder" + + class StartRecordingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StartRecordingResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StartRecordingResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","StartRecordingResponse") + kw["aname"] = "_StartRecordingResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "StartRecordingResponse_Holder" + self.pyclass = Holder + + class StartRecording_Task_Dec(ElementDeclaration): + literal = "StartRecording_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StartRecording_Task") + kw["aname"] = "_StartRecording_Task" + if ns0.StartRecordingRequestType_Def not in ns0.StartRecording_Task_Dec.__bases__: + bases = list(ns0.StartRecording_Task_Dec.__bases__) + bases.insert(0, ns0.StartRecordingRequestType_Def) + ns0.StartRecording_Task_Dec.__bases__ = tuple(bases) + + ns0.StartRecordingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StartRecording_Task_Dec_Holder" + + class StartRecording_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StartRecording_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StartRecording_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","StartRecording_TaskResponse") + kw["aname"] = "_StartRecording_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "StartRecording_TaskResponse_Holder" + self.pyclass = Holder + + class StopRecording_Dec(ElementDeclaration): + literal = "StopRecording" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StopRecording") + kw["aname"] = "_StopRecording" + if ns0.StopRecordingRequestType_Def not in ns0.StopRecording_Dec.__bases__: + bases = list(ns0.StopRecording_Dec.__bases__) + bases.insert(0, ns0.StopRecordingRequestType_Def) + ns0.StopRecording_Dec.__bases__ = tuple(bases) + + ns0.StopRecordingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StopRecording_Dec_Holder" + + class StopRecordingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StopRecordingResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StopRecordingResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","StopRecordingResponse") + kw["aname"] = "_StopRecordingResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "StopRecordingResponse_Holder" + self.pyclass = Holder + + class StopRecording_Task_Dec(ElementDeclaration): + literal = "StopRecording_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StopRecording_Task") + kw["aname"] = "_StopRecording_Task" + if ns0.StopRecordingRequestType_Def not in ns0.StopRecording_Task_Dec.__bases__: + bases = list(ns0.StopRecording_Task_Dec.__bases__) + bases.insert(0, ns0.StopRecordingRequestType_Def) + ns0.StopRecording_Task_Dec.__bases__ = tuple(bases) + + ns0.StopRecordingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StopRecording_Task_Dec_Holder" + + class StopRecording_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StopRecording_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StopRecording_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","StopRecording_TaskResponse") + kw["aname"] = "_StopRecording_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "StopRecording_TaskResponse_Holder" + self.pyclass = Holder + + class StartReplaying_Dec(ElementDeclaration): + literal = "StartReplaying" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StartReplaying") + kw["aname"] = "_StartReplaying" + if ns0.StartReplayingRequestType_Def not in ns0.StartReplaying_Dec.__bases__: + bases = list(ns0.StartReplaying_Dec.__bases__) + bases.insert(0, ns0.StartReplayingRequestType_Def) + ns0.StartReplaying_Dec.__bases__ = tuple(bases) + + ns0.StartReplayingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StartReplaying_Dec_Holder" + + class StartReplayingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StartReplayingResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StartReplayingResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","StartReplayingResponse") + kw["aname"] = "_StartReplayingResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "StartReplayingResponse_Holder" + self.pyclass = Holder + + class StartReplaying_Task_Dec(ElementDeclaration): + literal = "StartReplaying_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StartReplaying_Task") + kw["aname"] = "_StartReplaying_Task" + if ns0.StartReplayingRequestType_Def not in ns0.StartReplaying_Task_Dec.__bases__: + bases = list(ns0.StartReplaying_Task_Dec.__bases__) + bases.insert(0, ns0.StartReplayingRequestType_Def) + ns0.StartReplaying_Task_Dec.__bases__ = tuple(bases) + + ns0.StartReplayingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StartReplaying_Task_Dec_Holder" + + class StartReplaying_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StartReplaying_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StartReplaying_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","StartReplaying_TaskResponse") + kw["aname"] = "_StartReplaying_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "StartReplaying_TaskResponse_Holder" + self.pyclass = Holder + + class StopReplaying_Dec(ElementDeclaration): + literal = "StopReplaying" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StopReplaying") + kw["aname"] = "_StopReplaying" + if ns0.StopReplayingRequestType_Def not in ns0.StopReplaying_Dec.__bases__: + bases = list(ns0.StopReplaying_Dec.__bases__) + bases.insert(0, ns0.StopReplayingRequestType_Def) + ns0.StopReplaying_Dec.__bases__ = tuple(bases) + + ns0.StopReplayingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StopReplaying_Dec_Holder" + + class StopReplayingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StopReplayingResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StopReplayingResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","StopReplayingResponse") + kw["aname"] = "_StopReplayingResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "StopReplayingResponse_Holder" + self.pyclass = Holder + + class StopReplaying_Task_Dec(ElementDeclaration): + literal = "StopReplaying_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StopReplaying_Task") + kw["aname"] = "_StopReplaying_Task" + if ns0.StopReplayingRequestType_Def not in ns0.StopReplaying_Task_Dec.__bases__: + bases = list(ns0.StopReplaying_Task_Dec.__bases__) + bases.insert(0, ns0.StopReplayingRequestType_Def) + ns0.StopReplaying_Task_Dec.__bases__ = tuple(bases) + + ns0.StopReplayingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StopReplaying_Task_Dec_Holder" + + class StopReplaying_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StopReplaying_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StopReplaying_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","StopReplaying_TaskResponse") + kw["aname"] = "_StopReplaying_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "StopReplaying_TaskResponse_Holder" + self.pyclass = Holder + + class PromoteDisks_Dec(ElementDeclaration): + literal = "PromoteDisks" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PromoteDisks") + kw["aname"] = "_PromoteDisks" + if ns0.PromoteDisksRequestType_Def not in ns0.PromoteDisks_Dec.__bases__: + bases = list(ns0.PromoteDisks_Dec.__bases__) + bases.insert(0, ns0.PromoteDisksRequestType_Def) + ns0.PromoteDisks_Dec.__bases__ = tuple(bases) + + ns0.PromoteDisksRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PromoteDisks_Dec_Holder" + + class PromoteDisksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PromoteDisksResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PromoteDisksResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PromoteDisksResponse") + kw["aname"] = "_PromoteDisksResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PromoteDisksResponse_Holder" + self.pyclass = Holder + + class PromoteDisks_Task_Dec(ElementDeclaration): + literal = "PromoteDisks_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PromoteDisks_Task") + kw["aname"] = "_PromoteDisks_Task" + if ns0.PromoteDisksRequestType_Def not in ns0.PromoteDisks_Task_Dec.__bases__: + bases = list(ns0.PromoteDisks_Task_Dec.__bases__) + bases.insert(0, ns0.PromoteDisksRequestType_Def) + ns0.PromoteDisks_Task_Dec.__bases__ = tuple(bases) + + ns0.PromoteDisksRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PromoteDisks_Task_Dec_Holder" + + class PromoteDisks_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PromoteDisks_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PromoteDisks_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","PromoteDisks_TaskResponse") + kw["aname"] = "_PromoteDisks_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "PromoteDisks_TaskResponse_Holder" + self.pyclass = Holder + + class CreateScreenshot_Dec(ElementDeclaration): + literal = "CreateScreenshot" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateScreenshot") + kw["aname"] = "_CreateScreenshot" + if ns0.CreateScreenshotRequestType_Def not in ns0.CreateScreenshot_Dec.__bases__: + bases = list(ns0.CreateScreenshot_Dec.__bases__) + bases.insert(0, ns0.CreateScreenshotRequestType_Def) + ns0.CreateScreenshot_Dec.__bases__ = tuple(bases) + + ns0.CreateScreenshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateScreenshot_Dec_Holder" + + class CreateScreenshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateScreenshotResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateScreenshotResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateScreenshotResponse") + kw["aname"] = "_CreateScreenshotResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateScreenshotResponse_Holder" + self.pyclass = Holder + + class CreateScreenshot_Task_Dec(ElementDeclaration): + literal = "CreateScreenshot_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateScreenshot_Task") + kw["aname"] = "_CreateScreenshot_Task" + if ns0.CreateScreenshotRequestType_Def not in ns0.CreateScreenshot_Task_Dec.__bases__: + bases = list(ns0.CreateScreenshot_Task_Dec.__bases__) + bases.insert(0, ns0.CreateScreenshotRequestType_Def) + ns0.CreateScreenshot_Task_Dec.__bases__ = tuple(bases) + + ns0.CreateScreenshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateScreenshot_Task_Dec_Holder" + + class CreateScreenshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateScreenshot_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateScreenshot_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateScreenshot_TaskResponse") + kw["aname"] = "_CreateScreenshot_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateScreenshot_TaskResponse_Holder" + self.pyclass = Holder + + class QueryChangedDiskAreas_Dec(ElementDeclaration): + literal = "QueryChangedDiskAreas" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryChangedDiskAreas") + kw["aname"] = "_QueryChangedDiskAreas" + if ns0.QueryChangedDiskAreasRequestType_Def not in ns0.QueryChangedDiskAreas_Dec.__bases__: + bases = list(ns0.QueryChangedDiskAreas_Dec.__bases__) + bases.insert(0, ns0.QueryChangedDiskAreasRequestType_Def) + ns0.QueryChangedDiskAreas_Dec.__bases__ = tuple(bases) + + ns0.QueryChangedDiskAreasRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryChangedDiskAreas_Dec_Holder" + + class QueryChangedDiskAreasResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryChangedDiskAreasResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryChangedDiskAreasResponse_Dec.schema + TClist = [GTD("urn:vim25","DiskChangeInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryChangedDiskAreasResponse") + kw["aname"] = "_QueryChangedDiskAreasResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryChangedDiskAreasResponse_Holder" + self.pyclass = Holder + + class QueryUnownedFiles_Dec(ElementDeclaration): + literal = "QueryUnownedFiles" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryUnownedFiles") + kw["aname"] = "_QueryUnownedFiles" + if ns0.QueryUnownedFilesRequestType_Def not in ns0.QueryUnownedFiles_Dec.__bases__: + bases = list(ns0.QueryUnownedFiles_Dec.__bases__) + bases.insert(0, ns0.QueryUnownedFilesRequestType_Def) + ns0.QueryUnownedFiles_Dec.__bases__ = tuple(bases) + + ns0.QueryUnownedFilesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryUnownedFiles_Dec_Holder" + + class QueryUnownedFilesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryUnownedFilesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryUnownedFilesResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryUnownedFilesResponse") + kw["aname"] = "_QueryUnownedFilesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryUnownedFilesResponse_Holder" + self.pyclass = Holder + + class RemoveAlarm_Dec(ElementDeclaration): + literal = "RemoveAlarm" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveAlarm") + kw["aname"] = "_RemoveAlarm" + if ns0.RemoveAlarmRequestType_Def not in ns0.RemoveAlarm_Dec.__bases__: + bases = list(ns0.RemoveAlarm_Dec.__bases__) + bases.insert(0, ns0.RemoveAlarmRequestType_Def) + ns0.RemoveAlarm_Dec.__bases__ = tuple(bases) + + ns0.RemoveAlarmRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveAlarm_Dec_Holder" + + class RemoveAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveAlarmResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveAlarmResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveAlarmResponse") + kw["aname"] = "_RemoveAlarmResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveAlarmResponse_Holder" + self.pyclass = Holder + + class ReconfigureAlarm_Dec(ElementDeclaration): + literal = "ReconfigureAlarm" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureAlarm") + kw["aname"] = "_ReconfigureAlarm" + if ns0.ReconfigureAlarmRequestType_Def not in ns0.ReconfigureAlarm_Dec.__bases__: + bases = list(ns0.ReconfigureAlarm_Dec.__bases__) + bases.insert(0, ns0.ReconfigureAlarmRequestType_Def) + ns0.ReconfigureAlarm_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureAlarmRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureAlarm_Dec_Holder" + + class ReconfigureAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureAlarmResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureAlarmResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureAlarmResponse") + kw["aname"] = "_ReconfigureAlarmResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureAlarmResponse_Holder" + self.pyclass = Holder + + class CreateAlarm_Dec(ElementDeclaration): + literal = "CreateAlarm" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateAlarm") + kw["aname"] = "_CreateAlarm" + if ns0.CreateAlarmRequestType_Def not in ns0.CreateAlarm_Dec.__bases__: + bases = list(ns0.CreateAlarm_Dec.__bases__) + bases.insert(0, ns0.CreateAlarmRequestType_Def) + ns0.CreateAlarm_Dec.__bases__ = tuple(bases) + + ns0.CreateAlarmRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateAlarm_Dec_Holder" + + class CreateAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateAlarmResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateAlarmResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateAlarmResponse") + kw["aname"] = "_CreateAlarmResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateAlarmResponse_Holder" + self.pyclass = Holder + + class GetAlarm_Dec(ElementDeclaration): + literal = "GetAlarm" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GetAlarm") + kw["aname"] = "_GetAlarm" + if ns0.GetAlarmRequestType_Def not in ns0.GetAlarm_Dec.__bases__: + bases = list(ns0.GetAlarm_Dec.__bases__) + bases.insert(0, ns0.GetAlarmRequestType_Def) + ns0.GetAlarm_Dec.__bases__ = tuple(bases) + + ns0.GetAlarmRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GetAlarm_Dec_Holder" + + class GetAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GetAlarmResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GetAlarmResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GetAlarmResponse") + kw["aname"] = "_GetAlarmResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "GetAlarmResponse_Holder" + self.pyclass = Holder + + class GetAlarmActionsEnabled_Dec(ElementDeclaration): + literal = "GetAlarmActionsEnabled" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GetAlarmActionsEnabled") + kw["aname"] = "_GetAlarmActionsEnabled" + if ns0.GetAlarmActionsEnabledRequestType_Def not in ns0.GetAlarmActionsEnabled_Dec.__bases__: + bases = list(ns0.GetAlarmActionsEnabled_Dec.__bases__) + bases.insert(0, ns0.GetAlarmActionsEnabledRequestType_Def) + ns0.GetAlarmActionsEnabled_Dec.__bases__ = tuple(bases) + + ns0.GetAlarmActionsEnabledRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GetAlarmActionsEnabled_Dec_Holder" + + class GetAlarmActionsEnabledResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GetAlarmActionsEnabledResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GetAlarmActionsEnabledResponse_Dec.schema + TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GetAlarmActionsEnabledResponse") + kw["aname"] = "_GetAlarmActionsEnabledResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "GetAlarmActionsEnabledResponse_Holder" + self.pyclass = Holder + + class SetAlarmActionsEnabled_Dec(ElementDeclaration): + literal = "SetAlarmActionsEnabled" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetAlarmActionsEnabled") + kw["aname"] = "_SetAlarmActionsEnabled" + if ns0.SetAlarmActionsEnabledRequestType_Def not in ns0.SetAlarmActionsEnabled_Dec.__bases__: + bases = list(ns0.SetAlarmActionsEnabled_Dec.__bases__) + bases.insert(0, ns0.SetAlarmActionsEnabledRequestType_Def) + ns0.SetAlarmActionsEnabled_Dec.__bases__ = tuple(bases) + + ns0.SetAlarmActionsEnabledRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetAlarmActionsEnabled_Dec_Holder" + + class SetAlarmActionsEnabledResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetAlarmActionsEnabledResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetAlarmActionsEnabledResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetAlarmActionsEnabledResponse") + kw["aname"] = "_SetAlarmActionsEnabledResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetAlarmActionsEnabledResponse_Holder" + self.pyclass = Holder + + class GetAlarmState_Dec(ElementDeclaration): + literal = "GetAlarmState" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GetAlarmState") + kw["aname"] = "_GetAlarmState" + if ns0.GetAlarmStateRequestType_Def not in ns0.GetAlarmState_Dec.__bases__: + bases = list(ns0.GetAlarmState_Dec.__bases__) + bases.insert(0, ns0.GetAlarmStateRequestType_Def) + ns0.GetAlarmState_Dec.__bases__ = tuple(bases) + + ns0.GetAlarmStateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GetAlarmState_Dec_Holder" + + class GetAlarmStateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "GetAlarmStateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.GetAlarmStateResponse_Dec.schema + TClist = [GTD("urn:vim25","AlarmState",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","GetAlarmStateResponse") + kw["aname"] = "_GetAlarmStateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "GetAlarmStateResponse_Holder" + self.pyclass = Holder + + class AcknowledgeAlarm_Dec(ElementDeclaration): + literal = "AcknowledgeAlarm" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AcknowledgeAlarm") + kw["aname"] = "_AcknowledgeAlarm" + if ns0.AcknowledgeAlarmRequestType_Def not in ns0.AcknowledgeAlarm_Dec.__bases__: + bases = list(ns0.AcknowledgeAlarm_Dec.__bases__) + bases.insert(0, ns0.AcknowledgeAlarmRequestType_Def) + ns0.AcknowledgeAlarm_Dec.__bases__ = tuple(bases) + + ns0.AcknowledgeAlarmRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AcknowledgeAlarm_Dec_Holder" + + class AcknowledgeAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AcknowledgeAlarmResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AcknowledgeAlarmResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AcknowledgeAlarmResponse") + kw["aname"] = "_AcknowledgeAlarmResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AcknowledgeAlarmResponse_Holder" + self.pyclass = Holder + + class DVPortgroupReconfigure_Dec(ElementDeclaration): + literal = "DVPortgroupReconfigure" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVPortgroupReconfigure") + kw["aname"] = "_DVPortgroupReconfigure" + if ns0.DVPortgroupReconfigureRequestType_Def not in ns0.DVPortgroupReconfigure_Dec.__bases__: + bases = list(ns0.DVPortgroupReconfigure_Dec.__bases__) + bases.insert(0, ns0.DVPortgroupReconfigureRequestType_Def) + ns0.DVPortgroupReconfigure_Dec.__bases__ = tuple(bases) + + ns0.DVPortgroupReconfigureRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVPortgroupReconfigure_Dec_Holder" + + class DVPortgroupReconfigureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVPortgroupReconfigureResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVPortgroupReconfigureResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DVPortgroupReconfigureResponse") + kw["aname"] = "_DVPortgroupReconfigureResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DVPortgroupReconfigureResponse_Holder" + self.pyclass = Holder + + class DVSManagerQueryAvailableSwitchSpec_Dec(ElementDeclaration): + literal = "DVSManagerQueryAvailableSwitchSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSManagerQueryAvailableSwitchSpec") + kw["aname"] = "_DVSManagerQueryAvailableSwitchSpec" + if ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def not in ns0.DVSManagerQueryAvailableSwitchSpec_Dec.__bases__: + bases = list(ns0.DVSManagerQueryAvailableSwitchSpec_Dec.__bases__) + bases.insert(0, ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def) + ns0.DVSManagerQueryAvailableSwitchSpec_Dec.__bases__ = tuple(bases) + + ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryAvailableSwitchSpec_Dec_Holder" + + class DVSManagerQueryAvailableSwitchSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSManagerQueryAvailableSwitchSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSManagerQueryAvailableSwitchSpecResponse_Dec.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSManagerQueryAvailableSwitchSpecResponse") + kw["aname"] = "_DVSManagerQueryAvailableSwitchSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "DVSManagerQueryAvailableSwitchSpecResponse_Holder" + self.pyclass = Holder + + class DVSManagerQueryCompatibleHostForNewDvs_Dec(ElementDeclaration): + literal = "DVSManagerQueryCompatibleHostForNewDvs" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForNewDvs") + kw["aname"] = "_DVSManagerQueryCompatibleHostForNewDvs" + if ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def not in ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec.__bases__: + bases = list(ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec.__bases__) + bases.insert(0, ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def) + ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec.__bases__ = tuple(bases) + + ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryCompatibleHostForNewDvs_Dec_Holder" + + class DVSManagerQueryCompatibleHostForNewDvsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSManagerQueryCompatibleHostForNewDvsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSManagerQueryCompatibleHostForNewDvsResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForNewDvsResponse") + kw["aname"] = "_DVSManagerQueryCompatibleHostForNewDvsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "DVSManagerQueryCompatibleHostForNewDvsResponse_Holder" + self.pyclass = Holder + + class DVSManagerQueryCompatibleHostForExistingDvs_Dec(ElementDeclaration): + literal = "DVSManagerQueryCompatibleHostForExistingDvs" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForExistingDvs") + kw["aname"] = "_DVSManagerQueryCompatibleHostForExistingDvs" + if ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def not in ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec.__bases__: + bases = list(ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec.__bases__) + bases.insert(0, ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def) + ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec.__bases__ = tuple(bases) + + ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryCompatibleHostForExistingDvs_Dec_Holder" + + class DVSManagerQueryCompatibleHostForExistingDvsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSManagerQueryCompatibleHostForExistingDvsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSManagerQueryCompatibleHostForExistingDvsResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForExistingDvsResponse") + kw["aname"] = "_DVSManagerQueryCompatibleHostForExistingDvsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "DVSManagerQueryCompatibleHostForExistingDvsResponse_Holder" + self.pyclass = Holder + + class DVSManagerQueryCompatibleHostSpec_Dec(ElementDeclaration): + literal = "DVSManagerQueryCompatibleHostSpec" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostSpec") + kw["aname"] = "_DVSManagerQueryCompatibleHostSpec" + if ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def not in ns0.DVSManagerQueryCompatibleHostSpec_Dec.__bases__: + bases = list(ns0.DVSManagerQueryCompatibleHostSpec_Dec.__bases__) + bases.insert(0, ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def) + ns0.DVSManagerQueryCompatibleHostSpec_Dec.__bases__ = tuple(bases) + + ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryCompatibleHostSpec_Dec_Holder" + + class DVSManagerQueryCompatibleHostSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSManagerQueryCompatibleHostSpecResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSManagerQueryCompatibleHostSpecResponse_Dec.schema + TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostProductSpec",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostSpecResponse") + kw["aname"] = "_DVSManagerQueryCompatibleHostSpecResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "DVSManagerQueryCompatibleHostSpecResponse_Holder" + self.pyclass = Holder + + class DVSManagerQuerySwitchByUuid_Dec(ElementDeclaration): + literal = "DVSManagerQuerySwitchByUuid" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSManagerQuerySwitchByUuid") + kw["aname"] = "_DVSManagerQuerySwitchByUuid" + if ns0.DVSManagerQuerySwitchByUuidRequestType_Def not in ns0.DVSManagerQuerySwitchByUuid_Dec.__bases__: + bases = list(ns0.DVSManagerQuerySwitchByUuid_Dec.__bases__) + bases.insert(0, ns0.DVSManagerQuerySwitchByUuidRequestType_Def) + ns0.DVSManagerQuerySwitchByUuid_Dec.__bases__ = tuple(bases) + + ns0.DVSManagerQuerySwitchByUuidRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQuerySwitchByUuid_Dec_Holder" + + class DVSManagerQuerySwitchByUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSManagerQuerySwitchByUuidResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSManagerQuerySwitchByUuidResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSManagerQuerySwitchByUuidResponse") + kw["aname"] = "_DVSManagerQuerySwitchByUuidResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DVSManagerQuerySwitchByUuidResponse_Holder" + self.pyclass = Holder + + class DVSManagerQueryDvsConfigTarget_Dec(ElementDeclaration): + literal = "DVSManagerQueryDvsConfigTarget" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DVSManagerQueryDvsConfigTarget") + kw["aname"] = "_DVSManagerQueryDvsConfigTarget" + if ns0.DVSManagerQueryDvsConfigTargetRequestType_Def not in ns0.DVSManagerQueryDvsConfigTarget_Dec.__bases__: + bases = list(ns0.DVSManagerQueryDvsConfigTarget_Dec.__bases__) + bases.insert(0, ns0.DVSManagerQueryDvsConfigTargetRequestType_Def) + ns0.DVSManagerQueryDvsConfigTarget_Dec.__bases__ = tuple(bases) + + ns0.DVSManagerQueryDvsConfigTargetRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryDvsConfigTarget_Dec_Holder" + + class DVSManagerQueryDvsConfigTargetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DVSManagerQueryDvsConfigTargetResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DVSManagerQueryDvsConfigTargetResponse_Dec.schema + TClist = [GTD("urn:vim25","DVSManagerDvsConfigTarget",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","DVSManagerQueryDvsConfigTargetResponse") + kw["aname"] = "_DVSManagerQueryDvsConfigTargetResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "DVSManagerQueryDvsConfigTargetResponse_Holder" + self.pyclass = Holder + + class ReadNextEvents_Dec(ElementDeclaration): + literal = "ReadNextEvents" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReadNextEvents") + kw["aname"] = "_ReadNextEvents" + if ns0.ReadNextEventsRequestType_Def not in ns0.ReadNextEvents_Dec.__bases__: + bases = list(ns0.ReadNextEvents_Dec.__bases__) + bases.insert(0, ns0.ReadNextEventsRequestType_Def) + ns0.ReadNextEvents_Dec.__bases__ = tuple(bases) + + ns0.ReadNextEventsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReadNextEvents_Dec_Holder" + + class ReadNextEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReadNextEventsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReadNextEventsResponse_Dec.schema + TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReadNextEventsResponse") + kw["aname"] = "_ReadNextEventsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ReadNextEventsResponse_Holder" + self.pyclass = Holder + + class ReadPreviousEvents_Dec(ElementDeclaration): + literal = "ReadPreviousEvents" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReadPreviousEvents") + kw["aname"] = "_ReadPreviousEvents" + if ns0.ReadPreviousEventsRequestType_Def not in ns0.ReadPreviousEvents_Dec.__bases__: + bases = list(ns0.ReadPreviousEvents_Dec.__bases__) + bases.insert(0, ns0.ReadPreviousEventsRequestType_Def) + ns0.ReadPreviousEvents_Dec.__bases__ = tuple(bases) + + ns0.ReadPreviousEventsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReadPreviousEvents_Dec_Holder" + + class ReadPreviousEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReadPreviousEventsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReadPreviousEventsResponse_Dec.schema + TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ReadPreviousEventsResponse") + kw["aname"] = "_ReadPreviousEventsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ReadPreviousEventsResponse_Holder" + self.pyclass = Holder + + class RetrieveArgumentDescription_Dec(ElementDeclaration): + literal = "RetrieveArgumentDescription" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveArgumentDescription") + kw["aname"] = "_RetrieveArgumentDescription" + if ns0.RetrieveArgumentDescriptionRequestType_Def not in ns0.RetrieveArgumentDescription_Dec.__bases__: + bases = list(ns0.RetrieveArgumentDescription_Dec.__bases__) + bases.insert(0, ns0.RetrieveArgumentDescriptionRequestType_Def) + ns0.RetrieveArgumentDescription_Dec.__bases__ = tuple(bases) + + ns0.RetrieveArgumentDescriptionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveArgumentDescription_Dec_Holder" + + class RetrieveArgumentDescriptionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveArgumentDescriptionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveArgumentDescriptionResponse_Dec.schema + TClist = [GTD("urn:vim25","EventArgDesc",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveArgumentDescriptionResponse") + kw["aname"] = "_RetrieveArgumentDescriptionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveArgumentDescriptionResponse_Holder" + self.pyclass = Holder + + class CreateCollectorForEvents_Dec(ElementDeclaration): + literal = "CreateCollectorForEvents" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateCollectorForEvents") + kw["aname"] = "_CreateCollectorForEvents" + if ns0.CreateCollectorForEventsRequestType_Def not in ns0.CreateCollectorForEvents_Dec.__bases__: + bases = list(ns0.CreateCollectorForEvents_Dec.__bases__) + bases.insert(0, ns0.CreateCollectorForEventsRequestType_Def) + ns0.CreateCollectorForEvents_Dec.__bases__ = tuple(bases) + + ns0.CreateCollectorForEventsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateCollectorForEvents_Dec_Holder" + + class CreateCollectorForEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateCollectorForEventsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateCollectorForEventsResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateCollectorForEventsResponse") + kw["aname"] = "_CreateCollectorForEventsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateCollectorForEventsResponse_Holder" + self.pyclass = Holder + + class LogUserEvent_Dec(ElementDeclaration): + literal = "LogUserEvent" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LogUserEvent") + kw["aname"] = "_LogUserEvent" + if ns0.LogUserEventRequestType_Def not in ns0.LogUserEvent_Dec.__bases__: + bases = list(ns0.LogUserEvent_Dec.__bases__) + bases.insert(0, ns0.LogUserEventRequestType_Def) + ns0.LogUserEvent_Dec.__bases__ = tuple(bases) + + ns0.LogUserEventRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LogUserEvent_Dec_Holder" + + class LogUserEventResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "LogUserEventResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.LogUserEventResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","LogUserEventResponse") + kw["aname"] = "_LogUserEventResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "LogUserEventResponse_Holder" + self.pyclass = Holder + + class QueryEvents_Dec(ElementDeclaration): + literal = "QueryEvents" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryEvents") + kw["aname"] = "_QueryEvents" + if ns0.QueryEventsRequestType_Def not in ns0.QueryEvents_Dec.__bases__: + bases = list(ns0.QueryEvents_Dec.__bases__) + bases.insert(0, ns0.QueryEventsRequestType_Def) + ns0.QueryEvents_Dec.__bases__ = tuple(bases) + + ns0.QueryEventsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryEvents_Dec_Holder" + + class QueryEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryEventsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryEventsResponse_Dec.schema + TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryEventsResponse") + kw["aname"] = "_QueryEventsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryEventsResponse_Holder" + self.pyclass = Holder + + class PostEvent_Dec(ElementDeclaration): + literal = "PostEvent" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PostEvent") + kw["aname"] = "_PostEvent" + if ns0.PostEventRequestType_Def not in ns0.PostEvent_Dec.__bases__: + bases = list(ns0.PostEvent_Dec.__bases__) + bases.insert(0, ns0.PostEventRequestType_Def) + ns0.PostEvent_Dec.__bases__ = tuple(bases) + + ns0.PostEventRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PostEvent_Dec_Holder" + + class PostEventResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "PostEventResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.PostEventResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","PostEventResponse") + kw["aname"] = "_PostEventResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "PostEventResponse_Holder" + self.pyclass = Holder + + class AdminDisabledFault_Dec(ElementDeclaration): + literal = "AdminDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AdminDisabledFault") + kw["aname"] = "_AdminDisabledFault" + if ns0.AdminDisabled_Def not in ns0.AdminDisabledFault_Dec.__bases__: + bases = list(ns0.AdminDisabledFault_Dec.__bases__) + bases.insert(0, ns0.AdminDisabled_Def) + ns0.AdminDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.AdminDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AdminDisabledFault_Dec_Holder" + + class AdminNotDisabledFault_Dec(ElementDeclaration): + literal = "AdminNotDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AdminNotDisabledFault") + kw["aname"] = "_AdminNotDisabledFault" + if ns0.AdminNotDisabled_Def not in ns0.AdminNotDisabledFault_Dec.__bases__: + bases = list(ns0.AdminNotDisabledFault_Dec.__bases__) + bases.insert(0, ns0.AdminNotDisabled_Def) + ns0.AdminNotDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.AdminNotDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AdminNotDisabledFault_Dec_Holder" + + class AffinityConfiguredFault_Dec(ElementDeclaration): + literal = "AffinityConfiguredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AffinityConfiguredFault") + kw["aname"] = "_AffinityConfiguredFault" + if ns0.AffinityConfigured_Def not in ns0.AffinityConfiguredFault_Dec.__bases__: + bases = list(ns0.AffinityConfiguredFault_Dec.__bases__) + bases.insert(0, ns0.AffinityConfigured_Def) + ns0.AffinityConfiguredFault_Dec.__bases__ = tuple(bases) + + ns0.AffinityConfigured_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AffinityConfiguredFault_Dec_Holder" + + class AgentInstallFailedFault_Dec(ElementDeclaration): + literal = "AgentInstallFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AgentInstallFailedFault") + kw["aname"] = "_AgentInstallFailedFault" + if ns0.AgentInstallFailed_Def not in ns0.AgentInstallFailedFault_Dec.__bases__: + bases = list(ns0.AgentInstallFailedFault_Dec.__bases__) + bases.insert(0, ns0.AgentInstallFailed_Def) + ns0.AgentInstallFailedFault_Dec.__bases__ = tuple(bases) + + ns0.AgentInstallFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AgentInstallFailedFault_Dec_Holder" + + class AlreadyBeingManagedFault_Dec(ElementDeclaration): + literal = "AlreadyBeingManagedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AlreadyBeingManagedFault") + kw["aname"] = "_AlreadyBeingManagedFault" + if ns0.AlreadyBeingManaged_Def not in ns0.AlreadyBeingManagedFault_Dec.__bases__: + bases = list(ns0.AlreadyBeingManagedFault_Dec.__bases__) + bases.insert(0, ns0.AlreadyBeingManaged_Def) + ns0.AlreadyBeingManagedFault_Dec.__bases__ = tuple(bases) + + ns0.AlreadyBeingManaged_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AlreadyBeingManagedFault_Dec_Holder" + + class AlreadyConnectedFault_Dec(ElementDeclaration): + literal = "AlreadyConnectedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AlreadyConnectedFault") + kw["aname"] = "_AlreadyConnectedFault" + if ns0.AlreadyConnected_Def not in ns0.AlreadyConnectedFault_Dec.__bases__: + bases = list(ns0.AlreadyConnectedFault_Dec.__bases__) + bases.insert(0, ns0.AlreadyConnected_Def) + ns0.AlreadyConnectedFault_Dec.__bases__ = tuple(bases) + + ns0.AlreadyConnected_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AlreadyConnectedFault_Dec_Holder" + + class AlreadyExistsFault_Dec(ElementDeclaration): + literal = "AlreadyExistsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AlreadyExistsFault") + kw["aname"] = "_AlreadyExistsFault" + if ns0.AlreadyExists_Def not in ns0.AlreadyExistsFault_Dec.__bases__: + bases = list(ns0.AlreadyExistsFault_Dec.__bases__) + bases.insert(0, ns0.AlreadyExists_Def) + ns0.AlreadyExistsFault_Dec.__bases__ = tuple(bases) + + ns0.AlreadyExists_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AlreadyExistsFault_Dec_Holder" + + class AlreadyUpgradedFault_Dec(ElementDeclaration): + literal = "AlreadyUpgradedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AlreadyUpgradedFault") + kw["aname"] = "_AlreadyUpgradedFault" + if ns0.AlreadyUpgraded_Def not in ns0.AlreadyUpgradedFault_Dec.__bases__: + bases = list(ns0.AlreadyUpgradedFault_Dec.__bases__) + bases.insert(0, ns0.AlreadyUpgraded_Def) + ns0.AlreadyUpgradedFault_Dec.__bases__ = tuple(bases) + + ns0.AlreadyUpgraded_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AlreadyUpgradedFault_Dec_Holder" + + class ApplicationQuiesceFaultFault_Dec(ElementDeclaration): + literal = "ApplicationQuiesceFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ApplicationQuiesceFaultFault") + kw["aname"] = "_ApplicationQuiesceFaultFault" + if ns0.ApplicationQuiesceFault_Def not in ns0.ApplicationQuiesceFaultFault_Dec.__bases__: + bases = list(ns0.ApplicationQuiesceFaultFault_Dec.__bases__) + bases.insert(0, ns0.ApplicationQuiesceFault_Def) + ns0.ApplicationQuiesceFaultFault_Dec.__bases__ = tuple(bases) + + ns0.ApplicationQuiesceFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ApplicationQuiesceFaultFault_Dec_Holder" + + class AuthMinimumAdminPermissionFault_Dec(ElementDeclaration): + literal = "AuthMinimumAdminPermissionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AuthMinimumAdminPermissionFault") + kw["aname"] = "_AuthMinimumAdminPermissionFault" + if ns0.AuthMinimumAdminPermission_Def not in ns0.AuthMinimumAdminPermissionFault_Dec.__bases__: + bases = list(ns0.AuthMinimumAdminPermissionFault_Dec.__bases__) + bases.insert(0, ns0.AuthMinimumAdminPermission_Def) + ns0.AuthMinimumAdminPermissionFault_Dec.__bases__ = tuple(bases) + + ns0.AuthMinimumAdminPermission_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AuthMinimumAdminPermissionFault_Dec_Holder" + + class CannotAccessFileFault_Dec(ElementDeclaration): + literal = "CannotAccessFileFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAccessFileFault") + kw["aname"] = "_CannotAccessFileFault" + if ns0.CannotAccessFile_Def not in ns0.CannotAccessFileFault_Dec.__bases__: + bases = list(ns0.CannotAccessFileFault_Dec.__bases__) + bases.insert(0, ns0.CannotAccessFile_Def) + ns0.CannotAccessFileFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAccessFile_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessFileFault_Dec_Holder" + + class CannotAccessLocalSourceFault_Dec(ElementDeclaration): + literal = "CannotAccessLocalSourceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAccessLocalSourceFault") + kw["aname"] = "_CannotAccessLocalSourceFault" + if ns0.CannotAccessLocalSource_Def not in ns0.CannotAccessLocalSourceFault_Dec.__bases__: + bases = list(ns0.CannotAccessLocalSourceFault_Dec.__bases__) + bases.insert(0, ns0.CannotAccessLocalSource_Def) + ns0.CannotAccessLocalSourceFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAccessLocalSource_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessLocalSourceFault_Dec_Holder" + + class CannotAccessNetworkFault_Dec(ElementDeclaration): + literal = "CannotAccessNetworkFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAccessNetworkFault") + kw["aname"] = "_CannotAccessNetworkFault" + if ns0.CannotAccessNetwork_Def not in ns0.CannotAccessNetworkFault_Dec.__bases__: + bases = list(ns0.CannotAccessNetworkFault_Dec.__bases__) + bases.insert(0, ns0.CannotAccessNetwork_Def) + ns0.CannotAccessNetworkFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAccessNetwork_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessNetworkFault_Dec_Holder" + + class CannotAccessVmComponentFault_Dec(ElementDeclaration): + literal = "CannotAccessVmComponentFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAccessVmComponentFault") + kw["aname"] = "_CannotAccessVmComponentFault" + if ns0.CannotAccessVmComponent_Def not in ns0.CannotAccessVmComponentFault_Dec.__bases__: + bases = list(ns0.CannotAccessVmComponentFault_Dec.__bases__) + bases.insert(0, ns0.CannotAccessVmComponent_Def) + ns0.CannotAccessVmComponentFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAccessVmComponent_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmComponentFault_Dec_Holder" + + class CannotAccessVmConfigFault_Dec(ElementDeclaration): + literal = "CannotAccessVmConfigFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAccessVmConfigFault") + kw["aname"] = "_CannotAccessVmConfigFault" + if ns0.CannotAccessVmConfig_Def not in ns0.CannotAccessVmConfigFault_Dec.__bases__: + bases = list(ns0.CannotAccessVmConfigFault_Dec.__bases__) + bases.insert(0, ns0.CannotAccessVmConfig_Def) + ns0.CannotAccessVmConfigFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAccessVmConfig_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmConfigFault_Dec_Holder" + + class CannotAccessVmDeviceFault_Dec(ElementDeclaration): + literal = "CannotAccessVmDeviceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAccessVmDeviceFault") + kw["aname"] = "_CannotAccessVmDeviceFault" + if ns0.CannotAccessVmDevice_Def not in ns0.CannotAccessVmDeviceFault_Dec.__bases__: + bases = list(ns0.CannotAccessVmDeviceFault_Dec.__bases__) + bases.insert(0, ns0.CannotAccessVmDevice_Def) + ns0.CannotAccessVmDeviceFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAccessVmDevice_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmDeviceFault_Dec_Holder" + + class CannotAccessVmDiskFault_Dec(ElementDeclaration): + literal = "CannotAccessVmDiskFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAccessVmDiskFault") + kw["aname"] = "_CannotAccessVmDiskFault" + if ns0.CannotAccessVmDisk_Def not in ns0.CannotAccessVmDiskFault_Dec.__bases__: + bases = list(ns0.CannotAccessVmDiskFault_Dec.__bases__) + bases.insert(0, ns0.CannotAccessVmDisk_Def) + ns0.CannotAccessVmDiskFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAccessVmDisk_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmDiskFault_Dec_Holder" + + class CannotAddHostWithFTVmAsStandaloneFault_Dec(ElementDeclaration): + literal = "CannotAddHostWithFTVmAsStandaloneFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAddHostWithFTVmAsStandaloneFault") + kw["aname"] = "_CannotAddHostWithFTVmAsStandaloneFault" + if ns0.CannotAddHostWithFTVmAsStandalone_Def not in ns0.CannotAddHostWithFTVmAsStandaloneFault_Dec.__bases__: + bases = list(ns0.CannotAddHostWithFTVmAsStandaloneFault_Dec.__bases__) + bases.insert(0, ns0.CannotAddHostWithFTVmAsStandalone_Def) + ns0.CannotAddHostWithFTVmAsStandaloneFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAddHostWithFTVmAsStandalone_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAddHostWithFTVmAsStandaloneFault_Dec_Holder" + + class CannotAddHostWithFTVmToDifferentClusterFault_Dec(ElementDeclaration): + literal = "CannotAddHostWithFTVmToDifferentClusterFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAddHostWithFTVmToDifferentClusterFault") + kw["aname"] = "_CannotAddHostWithFTVmToDifferentClusterFault" + if ns0.CannotAddHostWithFTVmToDifferentCluster_Def not in ns0.CannotAddHostWithFTVmToDifferentClusterFault_Dec.__bases__: + bases = list(ns0.CannotAddHostWithFTVmToDifferentClusterFault_Dec.__bases__) + bases.insert(0, ns0.CannotAddHostWithFTVmToDifferentCluster_Def) + ns0.CannotAddHostWithFTVmToDifferentClusterFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAddHostWithFTVmToDifferentClusterFault_Dec_Holder" + + class CannotAddHostWithFTVmToNonHAClusterFault_Dec(ElementDeclaration): + literal = "CannotAddHostWithFTVmToNonHAClusterFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotAddHostWithFTVmToNonHAClusterFault") + kw["aname"] = "_CannotAddHostWithFTVmToNonHAClusterFault" + if ns0.CannotAddHostWithFTVmToNonHACluster_Def not in ns0.CannotAddHostWithFTVmToNonHAClusterFault_Dec.__bases__: + bases = list(ns0.CannotAddHostWithFTVmToNonHAClusterFault_Dec.__bases__) + bases.insert(0, ns0.CannotAddHostWithFTVmToNonHACluster_Def) + ns0.CannotAddHostWithFTVmToNonHAClusterFault_Dec.__bases__ = tuple(bases) + + ns0.CannotAddHostWithFTVmToNonHACluster_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotAddHostWithFTVmToNonHAClusterFault_Dec_Holder" + + class CannotCreateFileFault_Dec(ElementDeclaration): + literal = "CannotCreateFileFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotCreateFileFault") + kw["aname"] = "_CannotCreateFileFault" + if ns0.CannotCreateFile_Def not in ns0.CannotCreateFileFault_Dec.__bases__: + bases = list(ns0.CannotCreateFileFault_Dec.__bases__) + bases.insert(0, ns0.CannotCreateFile_Def) + ns0.CannotCreateFileFault_Dec.__bases__ = tuple(bases) + + ns0.CannotCreateFile_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotCreateFileFault_Dec_Holder" + + class CannotDecryptPasswordsFault_Dec(ElementDeclaration): + literal = "CannotDecryptPasswordsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotDecryptPasswordsFault") + kw["aname"] = "_CannotDecryptPasswordsFault" + if ns0.CannotDecryptPasswords_Def not in ns0.CannotDecryptPasswordsFault_Dec.__bases__: + bases = list(ns0.CannotDecryptPasswordsFault_Dec.__bases__) + bases.insert(0, ns0.CannotDecryptPasswords_Def) + ns0.CannotDecryptPasswordsFault_Dec.__bases__ = tuple(bases) + + ns0.CannotDecryptPasswords_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotDecryptPasswordsFault_Dec_Holder" + + class CannotDeleteFileFault_Dec(ElementDeclaration): + literal = "CannotDeleteFileFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotDeleteFileFault") + kw["aname"] = "_CannotDeleteFileFault" + if ns0.CannotDeleteFile_Def not in ns0.CannotDeleteFileFault_Dec.__bases__: + bases = list(ns0.CannotDeleteFileFault_Dec.__bases__) + bases.insert(0, ns0.CannotDeleteFile_Def) + ns0.CannotDeleteFileFault_Dec.__bases__ = tuple(bases) + + ns0.CannotDeleteFile_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotDeleteFileFault_Dec_Holder" + + class CannotDisableSnapshotFault_Dec(ElementDeclaration): + literal = "CannotDisableSnapshotFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotDisableSnapshotFault") + kw["aname"] = "_CannotDisableSnapshotFault" + if ns0.CannotDisableSnapshot_Def not in ns0.CannotDisableSnapshotFault_Dec.__bases__: + bases = list(ns0.CannotDisableSnapshotFault_Dec.__bases__) + bases.insert(0, ns0.CannotDisableSnapshot_Def) + ns0.CannotDisableSnapshotFault_Dec.__bases__ = tuple(bases) + + ns0.CannotDisableSnapshot_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotDisableSnapshotFault_Dec_Holder" + + class CannotDisconnectHostWithFaultToleranceVmFault_Dec(ElementDeclaration): + literal = "CannotDisconnectHostWithFaultToleranceVmFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotDisconnectHostWithFaultToleranceVmFault") + kw["aname"] = "_CannotDisconnectHostWithFaultToleranceVmFault" + if ns0.CannotDisconnectHostWithFaultToleranceVm_Def not in ns0.CannotDisconnectHostWithFaultToleranceVmFault_Dec.__bases__: + bases = list(ns0.CannotDisconnectHostWithFaultToleranceVmFault_Dec.__bases__) + bases.insert(0, ns0.CannotDisconnectHostWithFaultToleranceVm_Def) + ns0.CannotDisconnectHostWithFaultToleranceVmFault_Dec.__bases__ = tuple(bases) + + ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotDisconnectHostWithFaultToleranceVmFault_Dec_Holder" + + class CannotModifyConfigCpuRequirementsFault_Dec(ElementDeclaration): + literal = "CannotModifyConfigCpuRequirementsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotModifyConfigCpuRequirementsFault") + kw["aname"] = "_CannotModifyConfigCpuRequirementsFault" + if ns0.CannotModifyConfigCpuRequirements_Def not in ns0.CannotModifyConfigCpuRequirementsFault_Dec.__bases__: + bases = list(ns0.CannotModifyConfigCpuRequirementsFault_Dec.__bases__) + bases.insert(0, ns0.CannotModifyConfigCpuRequirements_Def) + ns0.CannotModifyConfigCpuRequirementsFault_Dec.__bases__ = tuple(bases) + + ns0.CannotModifyConfigCpuRequirements_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotModifyConfigCpuRequirementsFault_Dec_Holder" + + class CannotMoveFaultToleranceVmFault_Dec(ElementDeclaration): + literal = "CannotMoveFaultToleranceVmFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotMoveFaultToleranceVmFault") + kw["aname"] = "_CannotMoveFaultToleranceVmFault" + if ns0.CannotMoveFaultToleranceVm_Def not in ns0.CannotMoveFaultToleranceVmFault_Dec.__bases__: + bases = list(ns0.CannotMoveFaultToleranceVmFault_Dec.__bases__) + bases.insert(0, ns0.CannotMoveFaultToleranceVm_Def) + ns0.CannotMoveFaultToleranceVmFault_Dec.__bases__ = tuple(bases) + + ns0.CannotMoveFaultToleranceVm_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotMoveFaultToleranceVmFault_Dec_Holder" + + class CannotMoveHostWithFaultToleranceVmFault_Dec(ElementDeclaration): + literal = "CannotMoveHostWithFaultToleranceVmFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CannotMoveHostWithFaultToleranceVmFault") + kw["aname"] = "_CannotMoveHostWithFaultToleranceVmFault" + if ns0.CannotMoveHostWithFaultToleranceVm_Def not in ns0.CannotMoveHostWithFaultToleranceVmFault_Dec.__bases__: + bases = list(ns0.CannotMoveHostWithFaultToleranceVmFault_Dec.__bases__) + bases.insert(0, ns0.CannotMoveHostWithFaultToleranceVm_Def) + ns0.CannotMoveHostWithFaultToleranceVmFault_Dec.__bases__ = tuple(bases) + + ns0.CannotMoveHostWithFaultToleranceVm_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CannotMoveHostWithFaultToleranceVmFault_Dec_Holder" + + class CloneFromSnapshotNotSupportedFault_Dec(ElementDeclaration): + literal = "CloneFromSnapshotNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CloneFromSnapshotNotSupportedFault") + kw["aname"] = "_CloneFromSnapshotNotSupportedFault" + if ns0.CloneFromSnapshotNotSupported_Def not in ns0.CloneFromSnapshotNotSupportedFault_Dec.__bases__: + bases = list(ns0.CloneFromSnapshotNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.CloneFromSnapshotNotSupported_Def) + ns0.CloneFromSnapshotNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.CloneFromSnapshotNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CloneFromSnapshotNotSupportedFault_Dec_Holder" + + class ConcurrentAccessFault_Dec(ElementDeclaration): + literal = "ConcurrentAccessFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ConcurrentAccessFault") + kw["aname"] = "_ConcurrentAccessFault" + if ns0.ConcurrentAccess_Def not in ns0.ConcurrentAccessFault_Dec.__bases__: + bases = list(ns0.ConcurrentAccessFault_Dec.__bases__) + bases.insert(0, ns0.ConcurrentAccess_Def) + ns0.ConcurrentAccessFault_Dec.__bases__ = tuple(bases) + + ns0.ConcurrentAccess_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ConcurrentAccessFault_Dec_Holder" + + class ConnectedIsoFault_Dec(ElementDeclaration): + literal = "ConnectedIsoFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ConnectedIsoFault") + kw["aname"] = "_ConnectedIsoFault" + if ns0.ConnectedIso_Def not in ns0.ConnectedIsoFault_Dec.__bases__: + bases = list(ns0.ConnectedIsoFault_Dec.__bases__) + bases.insert(0, ns0.ConnectedIso_Def) + ns0.ConnectedIsoFault_Dec.__bases__ = tuple(bases) + + ns0.ConnectedIso_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ConnectedIsoFault_Dec_Holder" + + class CpuCompatibilityUnknownFault_Dec(ElementDeclaration): + literal = "CpuCompatibilityUnknownFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CpuCompatibilityUnknownFault") + kw["aname"] = "_CpuCompatibilityUnknownFault" + if ns0.CpuCompatibilityUnknown_Def not in ns0.CpuCompatibilityUnknownFault_Dec.__bases__: + bases = list(ns0.CpuCompatibilityUnknownFault_Dec.__bases__) + bases.insert(0, ns0.CpuCompatibilityUnknown_Def) + ns0.CpuCompatibilityUnknownFault_Dec.__bases__ = tuple(bases) + + ns0.CpuCompatibilityUnknown_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CpuCompatibilityUnknownFault_Dec_Holder" + + class CpuHotPlugNotSupportedFault_Dec(ElementDeclaration): + literal = "CpuHotPlugNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CpuHotPlugNotSupportedFault") + kw["aname"] = "_CpuHotPlugNotSupportedFault" + if ns0.CpuHotPlugNotSupported_Def not in ns0.CpuHotPlugNotSupportedFault_Dec.__bases__: + bases = list(ns0.CpuHotPlugNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.CpuHotPlugNotSupported_Def) + ns0.CpuHotPlugNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.CpuHotPlugNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CpuHotPlugNotSupportedFault_Dec_Holder" + + class CpuIncompatibleFault_Dec(ElementDeclaration): + literal = "CpuIncompatibleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CpuIncompatibleFault") + kw["aname"] = "_CpuIncompatibleFault" + if ns0.CpuIncompatible_Def not in ns0.CpuIncompatibleFault_Dec.__bases__: + bases = list(ns0.CpuIncompatibleFault_Dec.__bases__) + bases.insert(0, ns0.CpuIncompatible_Def) + ns0.CpuIncompatibleFault_Dec.__bases__ = tuple(bases) + + ns0.CpuIncompatible_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CpuIncompatibleFault_Dec_Holder" + + class CpuIncompatible1ECXFault_Dec(ElementDeclaration): + literal = "CpuIncompatible1ECXFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CpuIncompatible1ECXFault") + kw["aname"] = "_CpuIncompatible1ECXFault" + if ns0.CpuIncompatible1ECX_Def not in ns0.CpuIncompatible1ECXFault_Dec.__bases__: + bases = list(ns0.CpuIncompatible1ECXFault_Dec.__bases__) + bases.insert(0, ns0.CpuIncompatible1ECX_Def) + ns0.CpuIncompatible1ECXFault_Dec.__bases__ = tuple(bases) + + ns0.CpuIncompatible1ECX_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CpuIncompatible1ECXFault_Dec_Holder" + + class CpuIncompatible81EDXFault_Dec(ElementDeclaration): + literal = "CpuIncompatible81EDXFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CpuIncompatible81EDXFault") + kw["aname"] = "_CpuIncompatible81EDXFault" + if ns0.CpuIncompatible81EDX_Def not in ns0.CpuIncompatible81EDXFault_Dec.__bases__: + bases = list(ns0.CpuIncompatible81EDXFault_Dec.__bases__) + bases.insert(0, ns0.CpuIncompatible81EDX_Def) + ns0.CpuIncompatible81EDXFault_Dec.__bases__ = tuple(bases) + + ns0.CpuIncompatible81EDX_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CpuIncompatible81EDXFault_Dec_Holder" + + class CustomizationFaultFault_Dec(ElementDeclaration): + literal = "CustomizationFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CustomizationFaultFault") + kw["aname"] = "_CustomizationFaultFault" + if ns0.CustomizationFault_Def not in ns0.CustomizationFaultFault_Dec.__bases__: + bases = list(ns0.CustomizationFaultFault_Dec.__bases__) + bases.insert(0, ns0.CustomizationFault_Def) + ns0.CustomizationFaultFault_Dec.__bases__ = tuple(bases) + + ns0.CustomizationFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CustomizationFaultFault_Dec_Holder" + + class CustomizationPendingFault_Dec(ElementDeclaration): + literal = "CustomizationPendingFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CustomizationPendingFault") + kw["aname"] = "_CustomizationPendingFault" + if ns0.CustomizationPending_Def not in ns0.CustomizationPendingFault_Dec.__bases__: + bases = list(ns0.CustomizationPendingFault_Dec.__bases__) + bases.insert(0, ns0.CustomizationPending_Def) + ns0.CustomizationPendingFault_Dec.__bases__ = tuple(bases) + + ns0.CustomizationPending_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CustomizationPendingFault_Dec_Holder" + + class DasConfigFaultFault_Dec(ElementDeclaration): + literal = "DasConfigFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DasConfigFaultFault") + kw["aname"] = "_DasConfigFaultFault" + if ns0.DasConfigFault_Def not in ns0.DasConfigFaultFault_Dec.__bases__: + bases = list(ns0.DasConfigFaultFault_Dec.__bases__) + bases.insert(0, ns0.DasConfigFault_Def) + ns0.DasConfigFaultFault_Dec.__bases__ = tuple(bases) + + ns0.DasConfigFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DasConfigFaultFault_Dec_Holder" + + class DatabaseErrorFault_Dec(ElementDeclaration): + literal = "DatabaseErrorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DatabaseErrorFault") + kw["aname"] = "_DatabaseErrorFault" + if ns0.DatabaseError_Def not in ns0.DatabaseErrorFault_Dec.__bases__: + bases = list(ns0.DatabaseErrorFault_Dec.__bases__) + bases.insert(0, ns0.DatabaseError_Def) + ns0.DatabaseErrorFault_Dec.__bases__ = tuple(bases) + + ns0.DatabaseError_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DatabaseErrorFault_Dec_Holder" + + class DatacenterMismatchFault_Dec(ElementDeclaration): + literal = "DatacenterMismatchFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DatacenterMismatchFault") + kw["aname"] = "_DatacenterMismatchFault" + if ns0.DatacenterMismatch_Def not in ns0.DatacenterMismatchFault_Dec.__bases__: + bases = list(ns0.DatacenterMismatchFault_Dec.__bases__) + bases.insert(0, ns0.DatacenterMismatch_Def) + ns0.DatacenterMismatchFault_Dec.__bases__ = tuple(bases) + + ns0.DatacenterMismatch_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DatacenterMismatchFault_Dec_Holder" + + class DatastoreNotWritableOnHostFault_Dec(ElementDeclaration): + literal = "DatastoreNotWritableOnHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DatastoreNotWritableOnHostFault") + kw["aname"] = "_DatastoreNotWritableOnHostFault" + if ns0.DatastoreNotWritableOnHost_Def not in ns0.DatastoreNotWritableOnHostFault_Dec.__bases__: + bases = list(ns0.DatastoreNotWritableOnHostFault_Dec.__bases__) + bases.insert(0, ns0.DatastoreNotWritableOnHost_Def) + ns0.DatastoreNotWritableOnHostFault_Dec.__bases__ = tuple(bases) + + ns0.DatastoreNotWritableOnHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DatastoreNotWritableOnHostFault_Dec_Holder" + + class DestinationSwitchFullFault_Dec(ElementDeclaration): + literal = "DestinationSwitchFullFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestinationSwitchFullFault") + kw["aname"] = "_DestinationSwitchFullFault" + if ns0.DestinationSwitchFull_Def not in ns0.DestinationSwitchFullFault_Dec.__bases__: + bases = list(ns0.DestinationSwitchFullFault_Dec.__bases__) + bases.insert(0, ns0.DestinationSwitchFull_Def) + ns0.DestinationSwitchFullFault_Dec.__bases__ = tuple(bases) + + ns0.DestinationSwitchFull_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestinationSwitchFullFault_Dec_Holder" + + class DeviceBackingNotSupportedFault_Dec(ElementDeclaration): + literal = "DeviceBackingNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeviceBackingNotSupportedFault") + kw["aname"] = "_DeviceBackingNotSupportedFault" + if ns0.DeviceBackingNotSupported_Def not in ns0.DeviceBackingNotSupportedFault_Dec.__bases__: + bases = list(ns0.DeviceBackingNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.DeviceBackingNotSupported_Def) + ns0.DeviceBackingNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.DeviceBackingNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeviceBackingNotSupportedFault_Dec_Holder" + + class DeviceControllerNotSupportedFault_Dec(ElementDeclaration): + literal = "DeviceControllerNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeviceControllerNotSupportedFault") + kw["aname"] = "_DeviceControllerNotSupportedFault" + if ns0.DeviceControllerNotSupported_Def not in ns0.DeviceControllerNotSupportedFault_Dec.__bases__: + bases = list(ns0.DeviceControllerNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.DeviceControllerNotSupported_Def) + ns0.DeviceControllerNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.DeviceControllerNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeviceControllerNotSupportedFault_Dec_Holder" + + class DeviceHotPlugNotSupportedFault_Dec(ElementDeclaration): + literal = "DeviceHotPlugNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeviceHotPlugNotSupportedFault") + kw["aname"] = "_DeviceHotPlugNotSupportedFault" + if ns0.DeviceHotPlugNotSupported_Def not in ns0.DeviceHotPlugNotSupportedFault_Dec.__bases__: + bases = list(ns0.DeviceHotPlugNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.DeviceHotPlugNotSupported_Def) + ns0.DeviceHotPlugNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.DeviceHotPlugNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeviceHotPlugNotSupportedFault_Dec_Holder" + + class DeviceNotFoundFault_Dec(ElementDeclaration): + literal = "DeviceNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeviceNotFoundFault") + kw["aname"] = "_DeviceNotFoundFault" + if ns0.DeviceNotFound_Def not in ns0.DeviceNotFoundFault_Dec.__bases__: + bases = list(ns0.DeviceNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.DeviceNotFound_Def) + ns0.DeviceNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.DeviceNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeviceNotFoundFault_Dec_Holder" + + class DeviceNotSupportedFault_Dec(ElementDeclaration): + literal = "DeviceNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeviceNotSupportedFault") + kw["aname"] = "_DeviceNotSupportedFault" + if ns0.DeviceNotSupported_Def not in ns0.DeviceNotSupportedFault_Dec.__bases__: + bases = list(ns0.DeviceNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.DeviceNotSupported_Def) + ns0.DeviceNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.DeviceNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeviceNotSupportedFault_Dec_Holder" + + class DeviceUnsupportedForVmPlatformFault_Dec(ElementDeclaration): + literal = "DeviceUnsupportedForVmPlatformFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeviceUnsupportedForVmPlatformFault") + kw["aname"] = "_DeviceUnsupportedForVmPlatformFault" + if ns0.DeviceUnsupportedForVmPlatform_Def not in ns0.DeviceUnsupportedForVmPlatformFault_Dec.__bases__: + bases = list(ns0.DeviceUnsupportedForVmPlatformFault_Dec.__bases__) + bases.insert(0, ns0.DeviceUnsupportedForVmPlatform_Def) + ns0.DeviceUnsupportedForVmPlatformFault_Dec.__bases__ = tuple(bases) + + ns0.DeviceUnsupportedForVmPlatform_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeviceUnsupportedForVmPlatformFault_Dec_Holder" + + class DeviceUnsupportedForVmVersionFault_Dec(ElementDeclaration): + literal = "DeviceUnsupportedForVmVersionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeviceUnsupportedForVmVersionFault") + kw["aname"] = "_DeviceUnsupportedForVmVersionFault" + if ns0.DeviceUnsupportedForVmVersion_Def not in ns0.DeviceUnsupportedForVmVersionFault_Dec.__bases__: + bases = list(ns0.DeviceUnsupportedForVmVersionFault_Dec.__bases__) + bases.insert(0, ns0.DeviceUnsupportedForVmVersion_Def) + ns0.DeviceUnsupportedForVmVersionFault_Dec.__bases__ = tuple(bases) + + ns0.DeviceUnsupportedForVmVersion_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeviceUnsupportedForVmVersionFault_Dec_Holder" + + class DisableAdminNotSupportedFault_Dec(ElementDeclaration): + literal = "DisableAdminNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisableAdminNotSupportedFault") + kw["aname"] = "_DisableAdminNotSupportedFault" + if ns0.DisableAdminNotSupported_Def not in ns0.DisableAdminNotSupportedFault_Dec.__bases__: + bases = list(ns0.DisableAdminNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.DisableAdminNotSupported_Def) + ns0.DisableAdminNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.DisableAdminNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisableAdminNotSupportedFault_Dec_Holder" + + class DisallowedDiskModeChangeFault_Dec(ElementDeclaration): + literal = "DisallowedDiskModeChangeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisallowedDiskModeChangeFault") + kw["aname"] = "_DisallowedDiskModeChangeFault" + if ns0.DisallowedDiskModeChange_Def not in ns0.DisallowedDiskModeChangeFault_Dec.__bases__: + bases = list(ns0.DisallowedDiskModeChangeFault_Dec.__bases__) + bases.insert(0, ns0.DisallowedDiskModeChange_Def) + ns0.DisallowedDiskModeChangeFault_Dec.__bases__ = tuple(bases) + + ns0.DisallowedDiskModeChange_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisallowedDiskModeChangeFault_Dec_Holder" + + class DisallowedMigrationDeviceAttachedFault_Dec(ElementDeclaration): + literal = "DisallowedMigrationDeviceAttachedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisallowedMigrationDeviceAttachedFault") + kw["aname"] = "_DisallowedMigrationDeviceAttachedFault" + if ns0.DisallowedMigrationDeviceAttached_Def not in ns0.DisallowedMigrationDeviceAttachedFault_Dec.__bases__: + bases = list(ns0.DisallowedMigrationDeviceAttachedFault_Dec.__bases__) + bases.insert(0, ns0.DisallowedMigrationDeviceAttached_Def) + ns0.DisallowedMigrationDeviceAttachedFault_Dec.__bases__ = tuple(bases) + + ns0.DisallowedMigrationDeviceAttached_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisallowedMigrationDeviceAttachedFault_Dec_Holder" + + class DisallowedOperationOnFailoverHostFault_Dec(ElementDeclaration): + literal = "DisallowedOperationOnFailoverHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisallowedOperationOnFailoverHostFault") + kw["aname"] = "_DisallowedOperationOnFailoverHostFault" + if ns0.DisallowedOperationOnFailoverHost_Def not in ns0.DisallowedOperationOnFailoverHostFault_Dec.__bases__: + bases = list(ns0.DisallowedOperationOnFailoverHostFault_Dec.__bases__) + bases.insert(0, ns0.DisallowedOperationOnFailoverHost_Def) + ns0.DisallowedOperationOnFailoverHostFault_Dec.__bases__ = tuple(bases) + + ns0.DisallowedOperationOnFailoverHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisallowedOperationOnFailoverHostFault_Dec_Holder" + + class DiskMoveTypeNotSupportedFault_Dec(ElementDeclaration): + literal = "DiskMoveTypeNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DiskMoveTypeNotSupportedFault") + kw["aname"] = "_DiskMoveTypeNotSupportedFault" + if ns0.DiskMoveTypeNotSupported_Def not in ns0.DiskMoveTypeNotSupportedFault_Dec.__bases__: + bases = list(ns0.DiskMoveTypeNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.DiskMoveTypeNotSupported_Def) + ns0.DiskMoveTypeNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.DiskMoveTypeNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DiskMoveTypeNotSupportedFault_Dec_Holder" + + class DiskNotSupportedFault_Dec(ElementDeclaration): + literal = "DiskNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DiskNotSupportedFault") + kw["aname"] = "_DiskNotSupportedFault" + if ns0.DiskNotSupported_Def not in ns0.DiskNotSupportedFault_Dec.__bases__: + bases = list(ns0.DiskNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.DiskNotSupported_Def) + ns0.DiskNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.DiskNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DiskNotSupportedFault_Dec_Holder" + + class DrsDisabledOnVmFault_Dec(ElementDeclaration): + literal = "DrsDisabledOnVmFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DrsDisabledOnVmFault") + kw["aname"] = "_DrsDisabledOnVmFault" + if ns0.DrsDisabledOnVm_Def not in ns0.DrsDisabledOnVmFault_Dec.__bases__: + bases = list(ns0.DrsDisabledOnVmFault_Dec.__bases__) + bases.insert(0, ns0.DrsDisabledOnVm_Def) + ns0.DrsDisabledOnVmFault_Dec.__bases__ = tuple(bases) + + ns0.DrsDisabledOnVm_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DrsDisabledOnVmFault_Dec_Holder" + + class DrsVmotionIncompatibleFaultFault_Dec(ElementDeclaration): + literal = "DrsVmotionIncompatibleFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DrsVmotionIncompatibleFaultFault") + kw["aname"] = "_DrsVmotionIncompatibleFaultFault" + if ns0.DrsVmotionIncompatibleFault_Def not in ns0.DrsVmotionIncompatibleFaultFault_Dec.__bases__: + bases = list(ns0.DrsVmotionIncompatibleFaultFault_Dec.__bases__) + bases.insert(0, ns0.DrsVmotionIncompatibleFault_Def) + ns0.DrsVmotionIncompatibleFaultFault_Dec.__bases__ = tuple(bases) + + ns0.DrsVmotionIncompatibleFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DrsVmotionIncompatibleFaultFault_Dec_Holder" + + class DuplicateNameFault_Dec(ElementDeclaration): + literal = "DuplicateNameFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DuplicateNameFault") + kw["aname"] = "_DuplicateNameFault" + if ns0.DuplicateName_Def not in ns0.DuplicateNameFault_Dec.__bases__: + bases = list(ns0.DuplicateNameFault_Dec.__bases__) + bases.insert(0, ns0.DuplicateName_Def) + ns0.DuplicateNameFault_Dec.__bases__ = tuple(bases) + + ns0.DuplicateName_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DuplicateNameFault_Dec_Holder" + + class DvsFaultFault_Dec(ElementDeclaration): + literal = "DvsFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DvsFaultFault") + kw["aname"] = "_DvsFaultFault" + if ns0.DvsFault_Def not in ns0.DvsFaultFault_Dec.__bases__: + bases = list(ns0.DvsFaultFault_Dec.__bases__) + bases.insert(0, ns0.DvsFault_Def) + ns0.DvsFaultFault_Dec.__bases__ = tuple(bases) + + ns0.DvsFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DvsFaultFault_Dec_Holder" + + class DvsNotAuthorizedFault_Dec(ElementDeclaration): + literal = "DvsNotAuthorizedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DvsNotAuthorizedFault") + kw["aname"] = "_DvsNotAuthorizedFault" + if ns0.DvsNotAuthorized_Def not in ns0.DvsNotAuthorizedFault_Dec.__bases__: + bases = list(ns0.DvsNotAuthorizedFault_Dec.__bases__) + bases.insert(0, ns0.DvsNotAuthorized_Def) + ns0.DvsNotAuthorizedFault_Dec.__bases__ = tuple(bases) + + ns0.DvsNotAuthorized_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DvsNotAuthorizedFault_Dec_Holder" + + class DvsOperationBulkFaultFault_Dec(ElementDeclaration): + literal = "DvsOperationBulkFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DvsOperationBulkFaultFault") + kw["aname"] = "_DvsOperationBulkFaultFault" + if ns0.DvsOperationBulkFault_Def not in ns0.DvsOperationBulkFaultFault_Dec.__bases__: + bases = list(ns0.DvsOperationBulkFaultFault_Dec.__bases__) + bases.insert(0, ns0.DvsOperationBulkFault_Def) + ns0.DvsOperationBulkFaultFault_Dec.__bases__ = tuple(bases) + + ns0.DvsOperationBulkFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DvsOperationBulkFaultFault_Dec_Holder" + + class DvsScopeViolatedFault_Dec(ElementDeclaration): + literal = "DvsScopeViolatedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DvsScopeViolatedFault") + kw["aname"] = "_DvsScopeViolatedFault" + if ns0.DvsScopeViolated_Def not in ns0.DvsScopeViolatedFault_Dec.__bases__: + bases = list(ns0.DvsScopeViolatedFault_Dec.__bases__) + bases.insert(0, ns0.DvsScopeViolated_Def) + ns0.DvsScopeViolatedFault_Dec.__bases__ = tuple(bases) + + ns0.DvsScopeViolated_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DvsScopeViolatedFault_Dec_Holder" + + class EVCAdmissionFailedFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedFault") + kw["aname"] = "_EVCAdmissionFailedFault" + if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailed_Def) + ns0.EVCAdmissionFailedFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedFault_Dec_Holder" + + class EVCAdmissionFailedCPUFeaturesForModeFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedCPUFeaturesForModeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUFeaturesForModeFault") + kw["aname"] = "_EVCAdmissionFailedCPUFeaturesForModeFault" + if ns0.EVCAdmissionFailedCPUFeaturesForMode_Def not in ns0.EVCAdmissionFailedCPUFeaturesForModeFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUFeaturesForModeFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedCPUFeaturesForMode_Def) + ns0.EVCAdmissionFailedCPUFeaturesForModeFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUFeaturesForModeFault_Dec_Holder" + + class EVCAdmissionFailedCPUModelFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedCPUModelFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUModelFault") + kw["aname"] = "_EVCAdmissionFailedCPUModelFault" + if ns0.EVCAdmissionFailedCPUModel_Def not in ns0.EVCAdmissionFailedCPUModelFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUModelFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedCPUModel_Def) + ns0.EVCAdmissionFailedCPUModelFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedCPUModel_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUModelFault_Dec_Holder" + + class EVCAdmissionFailedCPUModelForModeFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedCPUModelForModeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUModelForModeFault") + kw["aname"] = "_EVCAdmissionFailedCPUModelForModeFault" + if ns0.EVCAdmissionFailedCPUModelForMode_Def not in ns0.EVCAdmissionFailedCPUModelForModeFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUModelForModeFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedCPUModelForMode_Def) + ns0.EVCAdmissionFailedCPUModelForModeFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedCPUModelForMode_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUModelForModeFault_Dec_Holder" + + class EVCAdmissionFailedCPUVendorFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedCPUVendorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUVendorFault") + kw["aname"] = "_EVCAdmissionFailedCPUVendorFault" + if ns0.EVCAdmissionFailedCPUVendor_Def not in ns0.EVCAdmissionFailedCPUVendorFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUVendorFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedCPUVendor_Def) + ns0.EVCAdmissionFailedCPUVendorFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedCPUVendor_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUVendorFault_Dec_Holder" + + class EVCAdmissionFailedCPUVendorUnknownFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedCPUVendorUnknownFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUVendorUnknownFault") + kw["aname"] = "_EVCAdmissionFailedCPUVendorUnknownFault" + if ns0.EVCAdmissionFailedCPUVendorUnknown_Def not in ns0.EVCAdmissionFailedCPUVendorUnknownFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedCPUVendorUnknownFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedCPUVendorUnknown_Def) + ns0.EVCAdmissionFailedCPUVendorUnknownFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUVendorUnknownFault_Dec_Holder" + + class EVCAdmissionFailedHostDisconnectedFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedHostDisconnectedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedHostDisconnectedFault") + kw["aname"] = "_EVCAdmissionFailedHostDisconnectedFault" + if ns0.EVCAdmissionFailedHostDisconnected_Def not in ns0.EVCAdmissionFailedHostDisconnectedFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedHostDisconnectedFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedHostDisconnected_Def) + ns0.EVCAdmissionFailedHostDisconnectedFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedHostDisconnected_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedHostDisconnectedFault_Dec_Holder" + + class EVCAdmissionFailedHostSoftwareFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedHostSoftwareFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedHostSoftwareFault") + kw["aname"] = "_EVCAdmissionFailedHostSoftwareFault" + if ns0.EVCAdmissionFailedHostSoftware_Def not in ns0.EVCAdmissionFailedHostSoftwareFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedHostSoftwareFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedHostSoftware_Def) + ns0.EVCAdmissionFailedHostSoftwareFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedHostSoftware_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedHostSoftwareFault_Dec_Holder" + + class EVCAdmissionFailedHostSoftwareForModeFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedHostSoftwareForModeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedHostSoftwareForModeFault") + kw["aname"] = "_EVCAdmissionFailedHostSoftwareForModeFault" + if ns0.EVCAdmissionFailedHostSoftwareForMode_Def not in ns0.EVCAdmissionFailedHostSoftwareForModeFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedHostSoftwareForModeFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedHostSoftwareForMode_Def) + ns0.EVCAdmissionFailedHostSoftwareForModeFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedHostSoftwareForModeFault_Dec_Holder" + + class EVCAdmissionFailedVmActiveFault_Dec(ElementDeclaration): + literal = "EVCAdmissionFailedVmActiveFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EVCAdmissionFailedVmActiveFault") + kw["aname"] = "_EVCAdmissionFailedVmActiveFault" + if ns0.EVCAdmissionFailedVmActive_Def not in ns0.EVCAdmissionFailedVmActiveFault_Dec.__bases__: + bases = list(ns0.EVCAdmissionFailedVmActiveFault_Dec.__bases__) + bases.insert(0, ns0.EVCAdmissionFailedVmActive_Def) + ns0.EVCAdmissionFailedVmActiveFault_Dec.__bases__ = tuple(bases) + + ns0.EVCAdmissionFailedVmActive_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedVmActiveFault_Dec_Holder" + + class EightHostLimitViolatedFault_Dec(ElementDeclaration): + literal = "EightHostLimitViolatedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EightHostLimitViolatedFault") + kw["aname"] = "_EightHostLimitViolatedFault" + if ns0.EightHostLimitViolated_Def not in ns0.EightHostLimitViolatedFault_Dec.__bases__: + bases = list(ns0.EightHostLimitViolatedFault_Dec.__bases__) + bases.insert(0, ns0.EightHostLimitViolated_Def) + ns0.EightHostLimitViolatedFault_Dec.__bases__ = tuple(bases) + + ns0.EightHostLimitViolated_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EightHostLimitViolatedFault_Dec_Holder" + + class ExpiredAddonLicenseFault_Dec(ElementDeclaration): + literal = "ExpiredAddonLicenseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExpiredAddonLicenseFault") + kw["aname"] = "_ExpiredAddonLicenseFault" + if ns0.ExpiredAddonLicense_Def not in ns0.ExpiredAddonLicenseFault_Dec.__bases__: + bases = list(ns0.ExpiredAddonLicenseFault_Dec.__bases__) + bases.insert(0, ns0.ExpiredAddonLicense_Def) + ns0.ExpiredAddonLicenseFault_Dec.__bases__ = tuple(bases) + + ns0.ExpiredAddonLicense_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExpiredAddonLicenseFault_Dec_Holder" + + class ExpiredEditionLicenseFault_Dec(ElementDeclaration): + literal = "ExpiredEditionLicenseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExpiredEditionLicenseFault") + kw["aname"] = "_ExpiredEditionLicenseFault" + if ns0.ExpiredEditionLicense_Def not in ns0.ExpiredEditionLicenseFault_Dec.__bases__: + bases = list(ns0.ExpiredEditionLicenseFault_Dec.__bases__) + bases.insert(0, ns0.ExpiredEditionLicense_Def) + ns0.ExpiredEditionLicenseFault_Dec.__bases__ = tuple(bases) + + ns0.ExpiredEditionLicense_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExpiredEditionLicenseFault_Dec_Holder" + + class ExpiredFeatureLicenseFault_Dec(ElementDeclaration): + literal = "ExpiredFeatureLicenseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExpiredFeatureLicenseFault") + kw["aname"] = "_ExpiredFeatureLicenseFault" + if ns0.ExpiredFeatureLicense_Def not in ns0.ExpiredFeatureLicenseFault_Dec.__bases__: + bases = list(ns0.ExpiredFeatureLicenseFault_Dec.__bases__) + bases.insert(0, ns0.ExpiredFeatureLicense_Def) + ns0.ExpiredFeatureLicenseFault_Dec.__bases__ = tuple(bases) + + ns0.ExpiredFeatureLicense_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExpiredFeatureLicenseFault_Dec_Holder" + + class ExtendedFaultFault_Dec(ElementDeclaration): + literal = "ExtendedFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExtendedFaultFault") + kw["aname"] = "_ExtendedFaultFault" + if ns0.ExtendedFault_Def not in ns0.ExtendedFaultFault_Dec.__bases__: + bases = list(ns0.ExtendedFaultFault_Dec.__bases__) + bases.insert(0, ns0.ExtendedFault_Def) + ns0.ExtendedFaultFault_Dec.__bases__ = tuple(bases) + + ns0.ExtendedFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExtendedFaultFault_Dec_Holder" + + class FaultToleranceAntiAffinityViolatedFault_Dec(ElementDeclaration): + literal = "FaultToleranceAntiAffinityViolatedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FaultToleranceAntiAffinityViolatedFault") + kw["aname"] = "_FaultToleranceAntiAffinityViolatedFault" + if ns0.FaultToleranceAntiAffinityViolated_Def not in ns0.FaultToleranceAntiAffinityViolatedFault_Dec.__bases__: + bases = list(ns0.FaultToleranceAntiAffinityViolatedFault_Dec.__bases__) + bases.insert(0, ns0.FaultToleranceAntiAffinityViolated_Def) + ns0.FaultToleranceAntiAffinityViolatedFault_Dec.__bases__ = tuple(bases) + + ns0.FaultToleranceAntiAffinityViolated_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceAntiAffinityViolatedFault_Dec_Holder" + + class FaultToleranceCpuIncompatibleFault_Dec(ElementDeclaration): + literal = "FaultToleranceCpuIncompatibleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FaultToleranceCpuIncompatibleFault") + kw["aname"] = "_FaultToleranceCpuIncompatibleFault" + if ns0.FaultToleranceCpuIncompatible_Def not in ns0.FaultToleranceCpuIncompatibleFault_Dec.__bases__: + bases = list(ns0.FaultToleranceCpuIncompatibleFault_Dec.__bases__) + bases.insert(0, ns0.FaultToleranceCpuIncompatible_Def) + ns0.FaultToleranceCpuIncompatibleFault_Dec.__bases__ = tuple(bases) + + ns0.FaultToleranceCpuIncompatible_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceCpuIncompatibleFault_Dec_Holder" + + class FaultToleranceNotLicensedFault_Dec(ElementDeclaration): + literal = "FaultToleranceNotLicensedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FaultToleranceNotLicensedFault") + kw["aname"] = "_FaultToleranceNotLicensedFault" + if ns0.FaultToleranceNotLicensed_Def not in ns0.FaultToleranceNotLicensedFault_Dec.__bases__: + bases = list(ns0.FaultToleranceNotLicensedFault_Dec.__bases__) + bases.insert(0, ns0.FaultToleranceNotLicensed_Def) + ns0.FaultToleranceNotLicensedFault_Dec.__bases__ = tuple(bases) + + ns0.FaultToleranceNotLicensed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceNotLicensedFault_Dec_Holder" + + class FaultToleranceNotSameBuildFault_Dec(ElementDeclaration): + literal = "FaultToleranceNotSameBuildFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FaultToleranceNotSameBuildFault") + kw["aname"] = "_FaultToleranceNotSameBuildFault" + if ns0.FaultToleranceNotSameBuild_Def not in ns0.FaultToleranceNotSameBuildFault_Dec.__bases__: + bases = list(ns0.FaultToleranceNotSameBuildFault_Dec.__bases__) + bases.insert(0, ns0.FaultToleranceNotSameBuild_Def) + ns0.FaultToleranceNotSameBuildFault_Dec.__bases__ = tuple(bases) + + ns0.FaultToleranceNotSameBuild_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceNotSameBuildFault_Dec_Holder" + + class FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec(ElementDeclaration): + literal = "FaultTolerancePrimaryPowerOnNotAttemptedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FaultTolerancePrimaryPowerOnNotAttemptedFault") + kw["aname"] = "_FaultTolerancePrimaryPowerOnNotAttemptedFault" + if ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def not in ns0.FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec.__bases__: + bases = list(ns0.FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec.__bases__) + bases.insert(0, ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def) + ns0.FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec.__bases__ = tuple(bases) + + ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec_Holder" + + class FileAlreadyExistsFault_Dec(ElementDeclaration): + literal = "FileAlreadyExistsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FileAlreadyExistsFault") + kw["aname"] = "_FileAlreadyExistsFault" + if ns0.FileAlreadyExists_Def not in ns0.FileAlreadyExistsFault_Dec.__bases__: + bases = list(ns0.FileAlreadyExistsFault_Dec.__bases__) + bases.insert(0, ns0.FileAlreadyExists_Def) + ns0.FileAlreadyExistsFault_Dec.__bases__ = tuple(bases) + + ns0.FileAlreadyExists_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FileAlreadyExistsFault_Dec_Holder" + + class FileBackedPortNotSupportedFault_Dec(ElementDeclaration): + literal = "FileBackedPortNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FileBackedPortNotSupportedFault") + kw["aname"] = "_FileBackedPortNotSupportedFault" + if ns0.FileBackedPortNotSupported_Def not in ns0.FileBackedPortNotSupportedFault_Dec.__bases__: + bases = list(ns0.FileBackedPortNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.FileBackedPortNotSupported_Def) + ns0.FileBackedPortNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.FileBackedPortNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FileBackedPortNotSupportedFault_Dec_Holder" + + class FileFaultFault_Dec(ElementDeclaration): + literal = "FileFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FileFaultFault") + kw["aname"] = "_FileFaultFault" + if ns0.FileFault_Def not in ns0.FileFaultFault_Dec.__bases__: + bases = list(ns0.FileFaultFault_Dec.__bases__) + bases.insert(0, ns0.FileFault_Def) + ns0.FileFaultFault_Dec.__bases__ = tuple(bases) + + ns0.FileFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FileFaultFault_Dec_Holder" + + class FileLockedFault_Dec(ElementDeclaration): + literal = "FileLockedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FileLockedFault") + kw["aname"] = "_FileLockedFault" + if ns0.FileLocked_Def not in ns0.FileLockedFault_Dec.__bases__: + bases = list(ns0.FileLockedFault_Dec.__bases__) + bases.insert(0, ns0.FileLocked_Def) + ns0.FileLockedFault_Dec.__bases__ = tuple(bases) + + ns0.FileLocked_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FileLockedFault_Dec_Holder" + + class FileNotFoundFault_Dec(ElementDeclaration): + literal = "FileNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FileNotFoundFault") + kw["aname"] = "_FileNotFoundFault" + if ns0.FileNotFound_Def not in ns0.FileNotFoundFault_Dec.__bases__: + bases = list(ns0.FileNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.FileNotFound_Def) + ns0.FileNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.FileNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FileNotFoundFault_Dec_Holder" + + class FileNotWritableFault_Dec(ElementDeclaration): + literal = "FileNotWritableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FileNotWritableFault") + kw["aname"] = "_FileNotWritableFault" + if ns0.FileNotWritable_Def not in ns0.FileNotWritableFault_Dec.__bases__: + bases = list(ns0.FileNotWritableFault_Dec.__bases__) + bases.insert(0, ns0.FileNotWritable_Def) + ns0.FileNotWritableFault_Dec.__bases__ = tuple(bases) + + ns0.FileNotWritable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FileNotWritableFault_Dec_Holder" + + class FileTooLargeFault_Dec(ElementDeclaration): + literal = "FileTooLargeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FileTooLargeFault") + kw["aname"] = "_FileTooLargeFault" + if ns0.FileTooLarge_Def not in ns0.FileTooLargeFault_Dec.__bases__: + bases = list(ns0.FileTooLargeFault_Dec.__bases__) + bases.insert(0, ns0.FileTooLarge_Def) + ns0.FileTooLargeFault_Dec.__bases__ = tuple(bases) + + ns0.FileTooLarge_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FileTooLargeFault_Dec_Holder" + + class FilesystemQuiesceFaultFault_Dec(ElementDeclaration): + literal = "FilesystemQuiesceFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FilesystemQuiesceFaultFault") + kw["aname"] = "_FilesystemQuiesceFaultFault" + if ns0.FilesystemQuiesceFault_Def not in ns0.FilesystemQuiesceFaultFault_Dec.__bases__: + bases = list(ns0.FilesystemQuiesceFaultFault_Dec.__bases__) + bases.insert(0, ns0.FilesystemQuiesceFault_Def) + ns0.FilesystemQuiesceFaultFault_Dec.__bases__ = tuple(bases) + + ns0.FilesystemQuiesceFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FilesystemQuiesceFaultFault_Dec_Holder" + + class FtIssuesOnHostFault_Dec(ElementDeclaration): + literal = "FtIssuesOnHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FtIssuesOnHostFault") + kw["aname"] = "_FtIssuesOnHostFault" + if ns0.FtIssuesOnHost_Def not in ns0.FtIssuesOnHostFault_Dec.__bases__: + bases = list(ns0.FtIssuesOnHostFault_Dec.__bases__) + bases.insert(0, ns0.FtIssuesOnHost_Def) + ns0.FtIssuesOnHostFault_Dec.__bases__ = tuple(bases) + + ns0.FtIssuesOnHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FtIssuesOnHostFault_Dec_Holder" + + class FullStorageVMotionNotSupportedFault_Dec(ElementDeclaration): + literal = "FullStorageVMotionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FullStorageVMotionNotSupportedFault") + kw["aname"] = "_FullStorageVMotionNotSupportedFault" + if ns0.FullStorageVMotionNotSupported_Def not in ns0.FullStorageVMotionNotSupportedFault_Dec.__bases__: + bases = list(ns0.FullStorageVMotionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.FullStorageVMotionNotSupported_Def) + ns0.FullStorageVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.FullStorageVMotionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FullStorageVMotionNotSupportedFault_Dec_Holder" + + class GenericDrsFaultFault_Dec(ElementDeclaration): + literal = "GenericDrsFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GenericDrsFaultFault") + kw["aname"] = "_GenericDrsFaultFault" + if ns0.GenericDrsFault_Def not in ns0.GenericDrsFaultFault_Dec.__bases__: + bases = list(ns0.GenericDrsFaultFault_Dec.__bases__) + bases.insert(0, ns0.GenericDrsFault_Def) + ns0.GenericDrsFaultFault_Dec.__bases__ = tuple(bases) + + ns0.GenericDrsFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GenericDrsFaultFault_Dec_Holder" + + class GenericVmConfigFaultFault_Dec(ElementDeclaration): + literal = "GenericVmConfigFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","GenericVmConfigFaultFault") + kw["aname"] = "_GenericVmConfigFaultFault" + if ns0.GenericVmConfigFault_Def not in ns0.GenericVmConfigFaultFault_Dec.__bases__: + bases = list(ns0.GenericVmConfigFaultFault_Dec.__bases__) + bases.insert(0, ns0.GenericVmConfigFault_Def) + ns0.GenericVmConfigFaultFault_Dec.__bases__ = tuple(bases) + + ns0.GenericVmConfigFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "GenericVmConfigFaultFault_Dec_Holder" + + class HAErrorsAtDestFault_Dec(ElementDeclaration): + literal = "HAErrorsAtDestFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HAErrorsAtDestFault") + kw["aname"] = "_HAErrorsAtDestFault" + if ns0.HAErrorsAtDest_Def not in ns0.HAErrorsAtDestFault_Dec.__bases__: + bases = list(ns0.HAErrorsAtDestFault_Dec.__bases__) + bases.insert(0, ns0.HAErrorsAtDest_Def) + ns0.HAErrorsAtDestFault_Dec.__bases__ = tuple(bases) + + ns0.HAErrorsAtDest_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HAErrorsAtDestFault_Dec_Holder" + + class HostConfigFailedFault_Dec(ElementDeclaration): + literal = "HostConfigFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostConfigFailedFault") + kw["aname"] = "_HostConfigFailedFault" + if ns0.HostConfigFailed_Def not in ns0.HostConfigFailedFault_Dec.__bases__: + bases = list(ns0.HostConfigFailedFault_Dec.__bases__) + bases.insert(0, ns0.HostConfigFailed_Def) + ns0.HostConfigFailedFault_Dec.__bases__ = tuple(bases) + + ns0.HostConfigFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostConfigFailedFault_Dec_Holder" + + class HostConfigFaultFault_Dec(ElementDeclaration): + literal = "HostConfigFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostConfigFaultFault") + kw["aname"] = "_HostConfigFaultFault" + if ns0.HostConfigFault_Def not in ns0.HostConfigFaultFault_Dec.__bases__: + bases = list(ns0.HostConfigFaultFault_Dec.__bases__) + bases.insert(0, ns0.HostConfigFault_Def) + ns0.HostConfigFaultFault_Dec.__bases__ = tuple(bases) + + ns0.HostConfigFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostConfigFaultFault_Dec_Holder" + + class HostConnectFaultFault_Dec(ElementDeclaration): + literal = "HostConnectFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostConnectFaultFault") + kw["aname"] = "_HostConnectFaultFault" + if ns0.HostConnectFault_Def not in ns0.HostConnectFaultFault_Dec.__bases__: + bases = list(ns0.HostConnectFaultFault_Dec.__bases__) + bases.insert(0, ns0.HostConnectFault_Def) + ns0.HostConnectFaultFault_Dec.__bases__ = tuple(bases) + + ns0.HostConnectFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostConnectFaultFault_Dec_Holder" + + class HostIncompatibleForFaultToleranceFault_Dec(ElementDeclaration): + literal = "HostIncompatibleForFaultToleranceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostIncompatibleForFaultToleranceFault") + kw["aname"] = "_HostIncompatibleForFaultToleranceFault" + if ns0.HostIncompatibleForFaultTolerance_Def not in ns0.HostIncompatibleForFaultToleranceFault_Dec.__bases__: + bases = list(ns0.HostIncompatibleForFaultToleranceFault_Dec.__bases__) + bases.insert(0, ns0.HostIncompatibleForFaultTolerance_Def) + ns0.HostIncompatibleForFaultToleranceFault_Dec.__bases__ = tuple(bases) + + ns0.HostIncompatibleForFaultTolerance_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostIncompatibleForFaultToleranceFault_Dec_Holder" + + class HostIncompatibleForRecordReplayFault_Dec(ElementDeclaration): + literal = "HostIncompatibleForRecordReplayFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostIncompatibleForRecordReplayFault") + kw["aname"] = "_HostIncompatibleForRecordReplayFault" + if ns0.HostIncompatibleForRecordReplay_Def not in ns0.HostIncompatibleForRecordReplayFault_Dec.__bases__: + bases = list(ns0.HostIncompatibleForRecordReplayFault_Dec.__bases__) + bases.insert(0, ns0.HostIncompatibleForRecordReplay_Def) + ns0.HostIncompatibleForRecordReplayFault_Dec.__bases__ = tuple(bases) + + ns0.HostIncompatibleForRecordReplay_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostIncompatibleForRecordReplayFault_Dec_Holder" + + class HostInventoryFullFault_Dec(ElementDeclaration): + literal = "HostInventoryFullFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostInventoryFullFault") + kw["aname"] = "_HostInventoryFullFault" + if ns0.HostInventoryFull_Def not in ns0.HostInventoryFullFault_Dec.__bases__: + bases = list(ns0.HostInventoryFullFault_Dec.__bases__) + bases.insert(0, ns0.HostInventoryFull_Def) + ns0.HostInventoryFullFault_Dec.__bases__ = tuple(bases) + + ns0.HostInventoryFull_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostInventoryFullFault_Dec_Holder" + + class HostPowerOpFailedFault_Dec(ElementDeclaration): + literal = "HostPowerOpFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostPowerOpFailedFault") + kw["aname"] = "_HostPowerOpFailedFault" + if ns0.HostPowerOpFailed_Def not in ns0.HostPowerOpFailedFault_Dec.__bases__: + bases = list(ns0.HostPowerOpFailedFault_Dec.__bases__) + bases.insert(0, ns0.HostPowerOpFailed_Def) + ns0.HostPowerOpFailedFault_Dec.__bases__ = tuple(bases) + + ns0.HostPowerOpFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostPowerOpFailedFault_Dec_Holder" + + class HotSnapshotMoveNotSupportedFault_Dec(ElementDeclaration): + literal = "HotSnapshotMoveNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HotSnapshotMoveNotSupportedFault") + kw["aname"] = "_HotSnapshotMoveNotSupportedFault" + if ns0.HotSnapshotMoveNotSupported_Def not in ns0.HotSnapshotMoveNotSupportedFault_Dec.__bases__: + bases = list(ns0.HotSnapshotMoveNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.HotSnapshotMoveNotSupported_Def) + ns0.HotSnapshotMoveNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.HotSnapshotMoveNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HotSnapshotMoveNotSupportedFault_Dec_Holder" + + class IDEDiskNotSupportedFault_Dec(ElementDeclaration): + literal = "IDEDiskNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IDEDiskNotSupportedFault") + kw["aname"] = "_IDEDiskNotSupportedFault" + if ns0.IDEDiskNotSupported_Def not in ns0.IDEDiskNotSupportedFault_Dec.__bases__: + bases = list(ns0.IDEDiskNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.IDEDiskNotSupported_Def) + ns0.IDEDiskNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.IDEDiskNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IDEDiskNotSupportedFault_Dec_Holder" + + class InUseFeatureManipulationDisallowedFault_Dec(ElementDeclaration): + literal = "InUseFeatureManipulationDisallowedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InUseFeatureManipulationDisallowedFault") + kw["aname"] = "_InUseFeatureManipulationDisallowedFault" + if ns0.InUseFeatureManipulationDisallowed_Def not in ns0.InUseFeatureManipulationDisallowedFault_Dec.__bases__: + bases = list(ns0.InUseFeatureManipulationDisallowedFault_Dec.__bases__) + bases.insert(0, ns0.InUseFeatureManipulationDisallowed_Def) + ns0.InUseFeatureManipulationDisallowedFault_Dec.__bases__ = tuple(bases) + + ns0.InUseFeatureManipulationDisallowed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InUseFeatureManipulationDisallowedFault_Dec_Holder" + + class InaccessibleDatastoreFault_Dec(ElementDeclaration): + literal = "InaccessibleDatastoreFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InaccessibleDatastoreFault") + kw["aname"] = "_InaccessibleDatastoreFault" + if ns0.InaccessibleDatastore_Def not in ns0.InaccessibleDatastoreFault_Dec.__bases__: + bases = list(ns0.InaccessibleDatastoreFault_Dec.__bases__) + bases.insert(0, ns0.InaccessibleDatastore_Def) + ns0.InaccessibleDatastoreFault_Dec.__bases__ = tuple(bases) + + ns0.InaccessibleDatastore_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InaccessibleDatastoreFault_Dec_Holder" + + class IncompatibleDefaultDeviceFault_Dec(ElementDeclaration): + literal = "IncompatibleDefaultDeviceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IncompatibleDefaultDeviceFault") + kw["aname"] = "_IncompatibleDefaultDeviceFault" + if ns0.IncompatibleDefaultDevice_Def not in ns0.IncompatibleDefaultDeviceFault_Dec.__bases__: + bases = list(ns0.IncompatibleDefaultDeviceFault_Dec.__bases__) + bases.insert(0, ns0.IncompatibleDefaultDevice_Def) + ns0.IncompatibleDefaultDeviceFault_Dec.__bases__ = tuple(bases) + + ns0.IncompatibleDefaultDevice_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IncompatibleDefaultDeviceFault_Dec_Holder" + + class IncompatibleHostForFtSecondaryFault_Dec(ElementDeclaration): + literal = "IncompatibleHostForFtSecondaryFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IncompatibleHostForFtSecondaryFault") + kw["aname"] = "_IncompatibleHostForFtSecondaryFault" + if ns0.IncompatibleHostForFtSecondary_Def not in ns0.IncompatibleHostForFtSecondaryFault_Dec.__bases__: + bases = list(ns0.IncompatibleHostForFtSecondaryFault_Dec.__bases__) + bases.insert(0, ns0.IncompatibleHostForFtSecondary_Def) + ns0.IncompatibleHostForFtSecondaryFault_Dec.__bases__ = tuple(bases) + + ns0.IncompatibleHostForFtSecondary_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IncompatibleHostForFtSecondaryFault_Dec_Holder" + + class IncompatibleSettingFault_Dec(ElementDeclaration): + literal = "IncompatibleSettingFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IncompatibleSettingFault") + kw["aname"] = "_IncompatibleSettingFault" + if ns0.IncompatibleSetting_Def not in ns0.IncompatibleSettingFault_Dec.__bases__: + bases = list(ns0.IncompatibleSettingFault_Dec.__bases__) + bases.insert(0, ns0.IncompatibleSetting_Def) + ns0.IncompatibleSettingFault_Dec.__bases__ = tuple(bases) + + ns0.IncompatibleSetting_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IncompatibleSettingFault_Dec_Holder" + + class IncorrectFileTypeFault_Dec(ElementDeclaration): + literal = "IncorrectFileTypeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IncorrectFileTypeFault") + kw["aname"] = "_IncorrectFileTypeFault" + if ns0.IncorrectFileType_Def not in ns0.IncorrectFileTypeFault_Dec.__bases__: + bases = list(ns0.IncorrectFileTypeFault_Dec.__bases__) + bases.insert(0, ns0.IncorrectFileType_Def) + ns0.IncorrectFileTypeFault_Dec.__bases__ = tuple(bases) + + ns0.IncorrectFileType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IncorrectFileTypeFault_Dec_Holder" + + class IncorrectHostInformationFault_Dec(ElementDeclaration): + literal = "IncorrectHostInformationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IncorrectHostInformationFault") + kw["aname"] = "_IncorrectHostInformationFault" + if ns0.IncorrectHostInformation_Def not in ns0.IncorrectHostInformationFault_Dec.__bases__: + bases = list(ns0.IncorrectHostInformationFault_Dec.__bases__) + bases.insert(0, ns0.IncorrectHostInformation_Def) + ns0.IncorrectHostInformationFault_Dec.__bases__ = tuple(bases) + + ns0.IncorrectHostInformation_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IncorrectHostInformationFault_Dec_Holder" + + class IndependentDiskVMotionNotSupportedFault_Dec(ElementDeclaration): + literal = "IndependentDiskVMotionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IndependentDiskVMotionNotSupportedFault") + kw["aname"] = "_IndependentDiskVMotionNotSupportedFault" + if ns0.IndependentDiskVMotionNotSupported_Def not in ns0.IndependentDiskVMotionNotSupportedFault_Dec.__bases__: + bases = list(ns0.IndependentDiskVMotionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.IndependentDiskVMotionNotSupported_Def) + ns0.IndependentDiskVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.IndependentDiskVMotionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IndependentDiskVMotionNotSupportedFault_Dec_Holder" + + class InsufficientCpuResourcesFaultFault_Dec(ElementDeclaration): + literal = "InsufficientCpuResourcesFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientCpuResourcesFaultFault") + kw["aname"] = "_InsufficientCpuResourcesFaultFault" + if ns0.InsufficientCpuResourcesFault_Def not in ns0.InsufficientCpuResourcesFaultFault_Dec.__bases__: + bases = list(ns0.InsufficientCpuResourcesFaultFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientCpuResourcesFault_Def) + ns0.InsufficientCpuResourcesFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientCpuResourcesFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientCpuResourcesFaultFault_Dec_Holder" + + class InsufficientFailoverResourcesFaultFault_Dec(ElementDeclaration): + literal = "InsufficientFailoverResourcesFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientFailoverResourcesFaultFault") + kw["aname"] = "_InsufficientFailoverResourcesFaultFault" + if ns0.InsufficientFailoverResourcesFault_Def not in ns0.InsufficientFailoverResourcesFaultFault_Dec.__bases__: + bases = list(ns0.InsufficientFailoverResourcesFaultFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientFailoverResourcesFault_Def) + ns0.InsufficientFailoverResourcesFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientFailoverResourcesFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientFailoverResourcesFaultFault_Dec_Holder" + + class InsufficientHostCapacityFaultFault_Dec(ElementDeclaration): + literal = "InsufficientHostCapacityFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientHostCapacityFaultFault") + kw["aname"] = "_InsufficientHostCapacityFaultFault" + if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientHostCapacityFaultFault_Dec.__bases__: + bases = list(ns0.InsufficientHostCapacityFaultFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientHostCapacityFault_Def) + ns0.InsufficientHostCapacityFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientHostCapacityFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientHostCapacityFaultFault_Dec_Holder" + + class InsufficientHostCpuCapacityFaultFault_Dec(ElementDeclaration): + literal = "InsufficientHostCpuCapacityFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientHostCpuCapacityFaultFault") + kw["aname"] = "_InsufficientHostCpuCapacityFaultFault" + if ns0.InsufficientHostCpuCapacityFault_Def not in ns0.InsufficientHostCpuCapacityFaultFault_Dec.__bases__: + bases = list(ns0.InsufficientHostCpuCapacityFaultFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientHostCpuCapacityFault_Def) + ns0.InsufficientHostCpuCapacityFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientHostCpuCapacityFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientHostCpuCapacityFaultFault_Dec_Holder" + + class InsufficientHostMemoryCapacityFaultFault_Dec(ElementDeclaration): + literal = "InsufficientHostMemoryCapacityFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientHostMemoryCapacityFaultFault") + kw["aname"] = "_InsufficientHostMemoryCapacityFaultFault" + if ns0.InsufficientHostMemoryCapacityFault_Def not in ns0.InsufficientHostMemoryCapacityFaultFault_Dec.__bases__: + bases = list(ns0.InsufficientHostMemoryCapacityFaultFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientHostMemoryCapacityFault_Def) + ns0.InsufficientHostMemoryCapacityFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientHostMemoryCapacityFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientHostMemoryCapacityFaultFault_Dec_Holder" + + class InsufficientMemoryResourcesFaultFault_Dec(ElementDeclaration): + literal = "InsufficientMemoryResourcesFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientMemoryResourcesFaultFault") + kw["aname"] = "_InsufficientMemoryResourcesFaultFault" + if ns0.InsufficientMemoryResourcesFault_Def not in ns0.InsufficientMemoryResourcesFaultFault_Dec.__bases__: + bases = list(ns0.InsufficientMemoryResourcesFaultFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientMemoryResourcesFault_Def) + ns0.InsufficientMemoryResourcesFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientMemoryResourcesFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientMemoryResourcesFaultFault_Dec_Holder" + + class InsufficientPerCpuCapacityFault_Dec(ElementDeclaration): + literal = "InsufficientPerCpuCapacityFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientPerCpuCapacityFault") + kw["aname"] = "_InsufficientPerCpuCapacityFault" + if ns0.InsufficientPerCpuCapacity_Def not in ns0.InsufficientPerCpuCapacityFault_Dec.__bases__: + bases = list(ns0.InsufficientPerCpuCapacityFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientPerCpuCapacity_Def) + ns0.InsufficientPerCpuCapacityFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientPerCpuCapacity_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientPerCpuCapacityFault_Dec_Holder" + + class InsufficientResourcesFaultFault_Dec(ElementDeclaration): + literal = "InsufficientResourcesFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientResourcesFaultFault") + kw["aname"] = "_InsufficientResourcesFaultFault" + if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientResourcesFaultFault_Dec.__bases__: + bases = list(ns0.InsufficientResourcesFaultFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientResourcesFault_Def) + ns0.InsufficientResourcesFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientResourcesFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientResourcesFaultFault_Dec_Holder" + + class InsufficientStandbyCpuResourceFault_Dec(ElementDeclaration): + literal = "InsufficientStandbyCpuResourceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientStandbyCpuResourceFault") + kw["aname"] = "_InsufficientStandbyCpuResourceFault" + if ns0.InsufficientStandbyCpuResource_Def not in ns0.InsufficientStandbyCpuResourceFault_Dec.__bases__: + bases = list(ns0.InsufficientStandbyCpuResourceFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientStandbyCpuResource_Def) + ns0.InsufficientStandbyCpuResourceFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientStandbyCpuResource_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientStandbyCpuResourceFault_Dec_Holder" + + class InsufficientStandbyMemoryResourceFault_Dec(ElementDeclaration): + literal = "InsufficientStandbyMemoryResourceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientStandbyMemoryResourceFault") + kw["aname"] = "_InsufficientStandbyMemoryResourceFault" + if ns0.InsufficientStandbyMemoryResource_Def not in ns0.InsufficientStandbyMemoryResourceFault_Dec.__bases__: + bases = list(ns0.InsufficientStandbyMemoryResourceFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientStandbyMemoryResource_Def) + ns0.InsufficientStandbyMemoryResourceFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientStandbyMemoryResource_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientStandbyMemoryResourceFault_Dec_Holder" + + class InsufficientStandbyResourceFault_Dec(ElementDeclaration): + literal = "InsufficientStandbyResourceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InsufficientStandbyResourceFault") + kw["aname"] = "_InsufficientStandbyResourceFault" + if ns0.InsufficientStandbyResource_Def not in ns0.InsufficientStandbyResourceFault_Dec.__bases__: + bases = list(ns0.InsufficientStandbyResourceFault_Dec.__bases__) + bases.insert(0, ns0.InsufficientStandbyResource_Def) + ns0.InsufficientStandbyResourceFault_Dec.__bases__ = tuple(bases) + + ns0.InsufficientStandbyResource_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InsufficientStandbyResourceFault_Dec_Holder" + + class InvalidAffinitySettingFaultFault_Dec(ElementDeclaration): + literal = "InvalidAffinitySettingFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidAffinitySettingFaultFault") + kw["aname"] = "_InvalidAffinitySettingFaultFault" + if ns0.InvalidAffinitySettingFault_Def not in ns0.InvalidAffinitySettingFaultFault_Dec.__bases__: + bases = list(ns0.InvalidAffinitySettingFaultFault_Dec.__bases__) + bases.insert(0, ns0.InvalidAffinitySettingFault_Def) + ns0.InvalidAffinitySettingFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidAffinitySettingFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidAffinitySettingFaultFault_Dec_Holder" + + class InvalidBmcRoleFault_Dec(ElementDeclaration): + literal = "InvalidBmcRoleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidBmcRoleFault") + kw["aname"] = "_InvalidBmcRoleFault" + if ns0.InvalidBmcRole_Def not in ns0.InvalidBmcRoleFault_Dec.__bases__: + bases = list(ns0.InvalidBmcRoleFault_Dec.__bases__) + bases.insert(0, ns0.InvalidBmcRole_Def) + ns0.InvalidBmcRoleFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidBmcRole_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidBmcRoleFault_Dec_Holder" + + class InvalidBundleFault_Dec(ElementDeclaration): + literal = "InvalidBundleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidBundleFault") + kw["aname"] = "_InvalidBundleFault" + if ns0.InvalidBundle_Def not in ns0.InvalidBundleFault_Dec.__bases__: + bases = list(ns0.InvalidBundleFault_Dec.__bases__) + bases.insert(0, ns0.InvalidBundle_Def) + ns0.InvalidBundleFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidBundle_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidBundleFault_Dec_Holder" + + class InvalidClientCertificateFault_Dec(ElementDeclaration): + literal = "InvalidClientCertificateFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidClientCertificateFault") + kw["aname"] = "_InvalidClientCertificateFault" + if ns0.InvalidClientCertificate_Def not in ns0.InvalidClientCertificateFault_Dec.__bases__: + bases = list(ns0.InvalidClientCertificateFault_Dec.__bases__) + bases.insert(0, ns0.InvalidClientCertificate_Def) + ns0.InvalidClientCertificateFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidClientCertificate_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidClientCertificateFault_Dec_Holder" + + class InvalidControllerFault_Dec(ElementDeclaration): + literal = "InvalidControllerFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidControllerFault") + kw["aname"] = "_InvalidControllerFault" + if ns0.InvalidController_Def not in ns0.InvalidControllerFault_Dec.__bases__: + bases = list(ns0.InvalidControllerFault_Dec.__bases__) + bases.insert(0, ns0.InvalidController_Def) + ns0.InvalidControllerFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidController_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidControllerFault_Dec_Holder" + + class InvalidDatastoreFault_Dec(ElementDeclaration): + literal = "InvalidDatastoreFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidDatastoreFault") + kw["aname"] = "_InvalidDatastoreFault" + if ns0.InvalidDatastore_Def not in ns0.InvalidDatastoreFault_Dec.__bases__: + bases = list(ns0.InvalidDatastoreFault_Dec.__bases__) + bases.insert(0, ns0.InvalidDatastore_Def) + ns0.InvalidDatastoreFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidDatastore_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidDatastoreFault_Dec_Holder" + + class InvalidDatastorePathFault_Dec(ElementDeclaration): + literal = "InvalidDatastorePathFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidDatastorePathFault") + kw["aname"] = "_InvalidDatastorePathFault" + if ns0.InvalidDatastorePath_Def not in ns0.InvalidDatastorePathFault_Dec.__bases__: + bases = list(ns0.InvalidDatastorePathFault_Dec.__bases__) + bases.insert(0, ns0.InvalidDatastorePath_Def) + ns0.InvalidDatastorePathFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidDatastorePath_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidDatastorePathFault_Dec_Holder" + + class InvalidDeviceBackingFault_Dec(ElementDeclaration): + literal = "InvalidDeviceBackingFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidDeviceBackingFault") + kw["aname"] = "_InvalidDeviceBackingFault" + if ns0.InvalidDeviceBacking_Def not in ns0.InvalidDeviceBackingFault_Dec.__bases__: + bases = list(ns0.InvalidDeviceBackingFault_Dec.__bases__) + bases.insert(0, ns0.InvalidDeviceBacking_Def) + ns0.InvalidDeviceBackingFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidDeviceBacking_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidDeviceBackingFault_Dec_Holder" + + class InvalidDeviceOperationFault_Dec(ElementDeclaration): + literal = "InvalidDeviceOperationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidDeviceOperationFault") + kw["aname"] = "_InvalidDeviceOperationFault" + if ns0.InvalidDeviceOperation_Def not in ns0.InvalidDeviceOperationFault_Dec.__bases__: + bases = list(ns0.InvalidDeviceOperationFault_Dec.__bases__) + bases.insert(0, ns0.InvalidDeviceOperation_Def) + ns0.InvalidDeviceOperationFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidDeviceOperation_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidDeviceOperationFault_Dec_Holder" + + class InvalidDeviceSpecFault_Dec(ElementDeclaration): + literal = "InvalidDeviceSpecFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidDeviceSpecFault") + kw["aname"] = "_InvalidDeviceSpecFault" + if ns0.InvalidDeviceSpec_Def not in ns0.InvalidDeviceSpecFault_Dec.__bases__: + bases = list(ns0.InvalidDeviceSpecFault_Dec.__bases__) + bases.insert(0, ns0.InvalidDeviceSpec_Def) + ns0.InvalidDeviceSpecFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidDeviceSpec_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidDeviceSpecFault_Dec_Holder" + + class InvalidDiskFormatFault_Dec(ElementDeclaration): + literal = "InvalidDiskFormatFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidDiskFormatFault") + kw["aname"] = "_InvalidDiskFormatFault" + if ns0.InvalidDiskFormat_Def not in ns0.InvalidDiskFormatFault_Dec.__bases__: + bases = list(ns0.InvalidDiskFormatFault_Dec.__bases__) + bases.insert(0, ns0.InvalidDiskFormat_Def) + ns0.InvalidDiskFormatFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidDiskFormat_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidDiskFormatFault_Dec_Holder" + + class InvalidDrsBehaviorForFtVmFault_Dec(ElementDeclaration): + literal = "InvalidDrsBehaviorForFtVmFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidDrsBehaviorForFtVmFault") + kw["aname"] = "_InvalidDrsBehaviorForFtVmFault" + if ns0.InvalidDrsBehaviorForFtVm_Def not in ns0.InvalidDrsBehaviorForFtVmFault_Dec.__bases__: + bases = list(ns0.InvalidDrsBehaviorForFtVmFault_Dec.__bases__) + bases.insert(0, ns0.InvalidDrsBehaviorForFtVm_Def) + ns0.InvalidDrsBehaviorForFtVmFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidDrsBehaviorForFtVm_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidDrsBehaviorForFtVmFault_Dec_Holder" + + class InvalidEditionLicenseFault_Dec(ElementDeclaration): + literal = "InvalidEditionLicenseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidEditionLicenseFault") + kw["aname"] = "_InvalidEditionLicenseFault" + if ns0.InvalidEditionLicense_Def not in ns0.InvalidEditionLicenseFault_Dec.__bases__: + bases = list(ns0.InvalidEditionLicenseFault_Dec.__bases__) + bases.insert(0, ns0.InvalidEditionLicense_Def) + ns0.InvalidEditionLicenseFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidEditionLicense_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidEditionLicenseFault_Dec_Holder" + + class InvalidEventFault_Dec(ElementDeclaration): + literal = "InvalidEventFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidEventFault") + kw["aname"] = "_InvalidEventFault" + if ns0.InvalidEvent_Def not in ns0.InvalidEventFault_Dec.__bases__: + bases = list(ns0.InvalidEventFault_Dec.__bases__) + bases.insert(0, ns0.InvalidEvent_Def) + ns0.InvalidEventFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidEvent_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidEventFault_Dec_Holder" + + class InvalidFolderFault_Dec(ElementDeclaration): + literal = "InvalidFolderFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidFolderFault") + kw["aname"] = "_InvalidFolderFault" + if ns0.InvalidFolder_Def not in ns0.InvalidFolderFault_Dec.__bases__: + bases = list(ns0.InvalidFolderFault_Dec.__bases__) + bases.insert(0, ns0.InvalidFolder_Def) + ns0.InvalidFolderFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidFolder_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidFolderFault_Dec_Holder" + + class InvalidFormatFault_Dec(ElementDeclaration): + literal = "InvalidFormatFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidFormatFault") + kw["aname"] = "_InvalidFormatFault" + if ns0.InvalidFormat_Def not in ns0.InvalidFormatFault_Dec.__bases__: + bases = list(ns0.InvalidFormatFault_Dec.__bases__) + bases.insert(0, ns0.InvalidFormat_Def) + ns0.InvalidFormatFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidFormat_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidFormatFault_Dec_Holder" + + class InvalidHostStateFault_Dec(ElementDeclaration): + literal = "InvalidHostStateFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidHostStateFault") + kw["aname"] = "_InvalidHostStateFault" + if ns0.InvalidHostState_Def not in ns0.InvalidHostStateFault_Dec.__bases__: + bases = list(ns0.InvalidHostStateFault_Dec.__bases__) + bases.insert(0, ns0.InvalidHostState_Def) + ns0.InvalidHostStateFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidHostState_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidHostStateFault_Dec_Holder" + + class InvalidIndexArgumentFault_Dec(ElementDeclaration): + literal = "InvalidIndexArgumentFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidIndexArgumentFault") + kw["aname"] = "_InvalidIndexArgumentFault" + if ns0.InvalidIndexArgument_Def not in ns0.InvalidIndexArgumentFault_Dec.__bases__: + bases = list(ns0.InvalidIndexArgumentFault_Dec.__bases__) + bases.insert(0, ns0.InvalidIndexArgument_Def) + ns0.InvalidIndexArgumentFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidIndexArgument_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidIndexArgumentFault_Dec_Holder" + + class InvalidIpmiLoginInfoFault_Dec(ElementDeclaration): + literal = "InvalidIpmiLoginInfoFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidIpmiLoginInfoFault") + kw["aname"] = "_InvalidIpmiLoginInfoFault" + if ns0.InvalidIpmiLoginInfo_Def not in ns0.InvalidIpmiLoginInfoFault_Dec.__bases__: + bases = list(ns0.InvalidIpmiLoginInfoFault_Dec.__bases__) + bases.insert(0, ns0.InvalidIpmiLoginInfo_Def) + ns0.InvalidIpmiLoginInfoFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidIpmiLoginInfo_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidIpmiLoginInfoFault_Dec_Holder" + + class InvalidIpmiMacAddressFault_Dec(ElementDeclaration): + literal = "InvalidIpmiMacAddressFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidIpmiMacAddressFault") + kw["aname"] = "_InvalidIpmiMacAddressFault" + if ns0.InvalidIpmiMacAddress_Def not in ns0.InvalidIpmiMacAddressFault_Dec.__bases__: + bases = list(ns0.InvalidIpmiMacAddressFault_Dec.__bases__) + bases.insert(0, ns0.InvalidIpmiMacAddress_Def) + ns0.InvalidIpmiMacAddressFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidIpmiMacAddress_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidIpmiMacAddressFault_Dec_Holder" + + class InvalidLicenseFault_Dec(ElementDeclaration): + literal = "InvalidLicenseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidLicenseFault") + kw["aname"] = "_InvalidLicenseFault" + if ns0.InvalidLicense_Def not in ns0.InvalidLicenseFault_Dec.__bases__: + bases = list(ns0.InvalidLicenseFault_Dec.__bases__) + bases.insert(0, ns0.InvalidLicense_Def) + ns0.InvalidLicenseFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidLicense_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidLicenseFault_Dec_Holder" + + class InvalidLocaleFault_Dec(ElementDeclaration): + literal = "InvalidLocaleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidLocaleFault") + kw["aname"] = "_InvalidLocaleFault" + if ns0.InvalidLocale_Def not in ns0.InvalidLocaleFault_Dec.__bases__: + bases = list(ns0.InvalidLocaleFault_Dec.__bases__) + bases.insert(0, ns0.InvalidLocale_Def) + ns0.InvalidLocaleFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidLocale_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidLocaleFault_Dec_Holder" + + class InvalidLoginFault_Dec(ElementDeclaration): + literal = "InvalidLoginFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidLoginFault") + kw["aname"] = "_InvalidLoginFault" + if ns0.InvalidLogin_Def not in ns0.InvalidLoginFault_Dec.__bases__: + bases = list(ns0.InvalidLoginFault_Dec.__bases__) + bases.insert(0, ns0.InvalidLogin_Def) + ns0.InvalidLoginFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidLogin_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidLoginFault_Dec_Holder" + + class InvalidNameFault_Dec(ElementDeclaration): + literal = "InvalidNameFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidNameFault") + kw["aname"] = "_InvalidNameFault" + if ns0.InvalidName_Def not in ns0.InvalidNameFault_Dec.__bases__: + bases = list(ns0.InvalidNameFault_Dec.__bases__) + bases.insert(0, ns0.InvalidName_Def) + ns0.InvalidNameFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidName_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidNameFault_Dec_Holder" + + class InvalidNasCredentialsFault_Dec(ElementDeclaration): + literal = "InvalidNasCredentialsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidNasCredentialsFault") + kw["aname"] = "_InvalidNasCredentialsFault" + if ns0.InvalidNasCredentials_Def not in ns0.InvalidNasCredentialsFault_Dec.__bases__: + bases = list(ns0.InvalidNasCredentialsFault_Dec.__bases__) + bases.insert(0, ns0.InvalidNasCredentials_Def) + ns0.InvalidNasCredentialsFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidNasCredentials_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidNasCredentialsFault_Dec_Holder" + + class InvalidNetworkInTypeFault_Dec(ElementDeclaration): + literal = "InvalidNetworkInTypeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidNetworkInTypeFault") + kw["aname"] = "_InvalidNetworkInTypeFault" + if ns0.InvalidNetworkInType_Def not in ns0.InvalidNetworkInTypeFault_Dec.__bases__: + bases = list(ns0.InvalidNetworkInTypeFault_Dec.__bases__) + bases.insert(0, ns0.InvalidNetworkInType_Def) + ns0.InvalidNetworkInTypeFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidNetworkInType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidNetworkInTypeFault_Dec_Holder" + + class InvalidNetworkResourceFault_Dec(ElementDeclaration): + literal = "InvalidNetworkResourceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidNetworkResourceFault") + kw["aname"] = "_InvalidNetworkResourceFault" + if ns0.InvalidNetworkResource_Def not in ns0.InvalidNetworkResourceFault_Dec.__bases__: + bases = list(ns0.InvalidNetworkResourceFault_Dec.__bases__) + bases.insert(0, ns0.InvalidNetworkResource_Def) + ns0.InvalidNetworkResourceFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidNetworkResource_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidNetworkResourceFault_Dec_Holder" + + class InvalidOperationOnSecondaryVmFault_Dec(ElementDeclaration): + literal = "InvalidOperationOnSecondaryVmFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidOperationOnSecondaryVmFault") + kw["aname"] = "_InvalidOperationOnSecondaryVmFault" + if ns0.InvalidOperationOnSecondaryVm_Def not in ns0.InvalidOperationOnSecondaryVmFault_Dec.__bases__: + bases = list(ns0.InvalidOperationOnSecondaryVmFault_Dec.__bases__) + bases.insert(0, ns0.InvalidOperationOnSecondaryVm_Def) + ns0.InvalidOperationOnSecondaryVmFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidOperationOnSecondaryVm_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidOperationOnSecondaryVmFault_Dec_Holder" + + class InvalidPowerStateFault_Dec(ElementDeclaration): + literal = "InvalidPowerStateFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidPowerStateFault") + kw["aname"] = "_InvalidPowerStateFault" + if ns0.InvalidPowerState_Def not in ns0.InvalidPowerStateFault_Dec.__bases__: + bases = list(ns0.InvalidPowerStateFault_Dec.__bases__) + bases.insert(0, ns0.InvalidPowerState_Def) + ns0.InvalidPowerStateFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidPowerState_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidPowerStateFault_Dec_Holder" + + class InvalidPrivilegeFault_Dec(ElementDeclaration): + literal = "InvalidPrivilegeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidPrivilegeFault") + kw["aname"] = "_InvalidPrivilegeFault" + if ns0.InvalidPrivilege_Def not in ns0.InvalidPrivilegeFault_Dec.__bases__: + bases = list(ns0.InvalidPrivilegeFault_Dec.__bases__) + bases.insert(0, ns0.InvalidPrivilege_Def) + ns0.InvalidPrivilegeFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidPrivilege_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidPrivilegeFault_Dec_Holder" + + class InvalidPropertyTypeFault_Dec(ElementDeclaration): + literal = "InvalidPropertyTypeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidPropertyTypeFault") + kw["aname"] = "_InvalidPropertyTypeFault" + if ns0.InvalidPropertyType_Def not in ns0.InvalidPropertyTypeFault_Dec.__bases__: + bases = list(ns0.InvalidPropertyTypeFault_Dec.__bases__) + bases.insert(0, ns0.InvalidPropertyType_Def) + ns0.InvalidPropertyTypeFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidPropertyType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidPropertyTypeFault_Dec_Holder" + + class InvalidPropertyValueFault_Dec(ElementDeclaration): + literal = "InvalidPropertyValueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidPropertyValueFault") + kw["aname"] = "_InvalidPropertyValueFault" + if ns0.InvalidPropertyValue_Def not in ns0.InvalidPropertyValueFault_Dec.__bases__: + bases = list(ns0.InvalidPropertyValueFault_Dec.__bases__) + bases.insert(0, ns0.InvalidPropertyValue_Def) + ns0.InvalidPropertyValueFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidPropertyValue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidPropertyValueFault_Dec_Holder" + + class InvalidResourcePoolStructureFaultFault_Dec(ElementDeclaration): + literal = "InvalidResourcePoolStructureFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidResourcePoolStructureFaultFault") + kw["aname"] = "_InvalidResourcePoolStructureFaultFault" + if ns0.InvalidResourcePoolStructureFault_Def not in ns0.InvalidResourcePoolStructureFaultFault_Dec.__bases__: + bases = list(ns0.InvalidResourcePoolStructureFaultFault_Dec.__bases__) + bases.insert(0, ns0.InvalidResourcePoolStructureFault_Def) + ns0.InvalidResourcePoolStructureFaultFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidResourcePoolStructureFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidResourcePoolStructureFaultFault_Dec_Holder" + + class InvalidSnapshotFormatFault_Dec(ElementDeclaration): + literal = "InvalidSnapshotFormatFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidSnapshotFormatFault") + kw["aname"] = "_InvalidSnapshotFormatFault" + if ns0.InvalidSnapshotFormat_Def not in ns0.InvalidSnapshotFormatFault_Dec.__bases__: + bases = list(ns0.InvalidSnapshotFormatFault_Dec.__bases__) + bases.insert(0, ns0.InvalidSnapshotFormat_Def) + ns0.InvalidSnapshotFormatFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidSnapshotFormat_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidSnapshotFormatFault_Dec_Holder" + + class InvalidStateFault_Dec(ElementDeclaration): + literal = "InvalidStateFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidStateFault") + kw["aname"] = "_InvalidStateFault" + if ns0.InvalidState_Def not in ns0.InvalidStateFault_Dec.__bases__: + bases = list(ns0.InvalidStateFault_Dec.__bases__) + bases.insert(0, ns0.InvalidState_Def) + ns0.InvalidStateFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidState_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidStateFault_Dec_Holder" + + class InvalidVmConfigFault_Dec(ElementDeclaration): + literal = "InvalidVmConfigFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InvalidVmConfigFault") + kw["aname"] = "_InvalidVmConfigFault" + if ns0.InvalidVmConfig_Def not in ns0.InvalidVmConfigFault_Dec.__bases__: + bases = list(ns0.InvalidVmConfigFault_Dec.__bases__) + bases.insert(0, ns0.InvalidVmConfig_Def) + ns0.InvalidVmConfigFault_Dec.__bases__ = tuple(bases) + + ns0.InvalidVmConfig_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InvalidVmConfigFault_Dec_Holder" + + class InventoryHasStandardAloneHostsFault_Dec(ElementDeclaration): + literal = "InventoryHasStandardAloneHostsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InventoryHasStandardAloneHostsFault") + kw["aname"] = "_InventoryHasStandardAloneHostsFault" + if ns0.InventoryHasStandardAloneHosts_Def not in ns0.InventoryHasStandardAloneHostsFault_Dec.__bases__: + bases = list(ns0.InventoryHasStandardAloneHostsFault_Dec.__bases__) + bases.insert(0, ns0.InventoryHasStandardAloneHosts_Def) + ns0.InventoryHasStandardAloneHostsFault_Dec.__bases__ = tuple(bases) + + ns0.InventoryHasStandardAloneHosts_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InventoryHasStandardAloneHostsFault_Dec_Holder" + + class IpHostnameGeneratorErrorFault_Dec(ElementDeclaration): + literal = "IpHostnameGeneratorErrorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","IpHostnameGeneratorErrorFault") + kw["aname"] = "_IpHostnameGeneratorErrorFault" + if ns0.IpHostnameGeneratorError_Def not in ns0.IpHostnameGeneratorErrorFault_Dec.__bases__: + bases = list(ns0.IpHostnameGeneratorErrorFault_Dec.__bases__) + bases.insert(0, ns0.IpHostnameGeneratorError_Def) + ns0.IpHostnameGeneratorErrorFault_Dec.__bases__ = tuple(bases) + + ns0.IpHostnameGeneratorError_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "IpHostnameGeneratorErrorFault_Dec_Holder" + + class LegacyNetworkInterfaceInUseFault_Dec(ElementDeclaration): + literal = "LegacyNetworkInterfaceInUseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LegacyNetworkInterfaceInUseFault") + kw["aname"] = "_LegacyNetworkInterfaceInUseFault" + if ns0.LegacyNetworkInterfaceInUse_Def not in ns0.LegacyNetworkInterfaceInUseFault_Dec.__bases__: + bases = list(ns0.LegacyNetworkInterfaceInUseFault_Dec.__bases__) + bases.insert(0, ns0.LegacyNetworkInterfaceInUse_Def) + ns0.LegacyNetworkInterfaceInUseFault_Dec.__bases__ = tuple(bases) + + ns0.LegacyNetworkInterfaceInUse_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LegacyNetworkInterfaceInUseFault_Dec_Holder" + + class LicenseAssignmentFailedFault_Dec(ElementDeclaration): + literal = "LicenseAssignmentFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LicenseAssignmentFailedFault") + kw["aname"] = "_LicenseAssignmentFailedFault" + if ns0.LicenseAssignmentFailed_Def not in ns0.LicenseAssignmentFailedFault_Dec.__bases__: + bases = list(ns0.LicenseAssignmentFailedFault_Dec.__bases__) + bases.insert(0, ns0.LicenseAssignmentFailed_Def) + ns0.LicenseAssignmentFailedFault_Dec.__bases__ = tuple(bases) + + ns0.LicenseAssignmentFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LicenseAssignmentFailedFault_Dec_Holder" + + class LicenseDowngradeDisallowedFault_Dec(ElementDeclaration): + literal = "LicenseDowngradeDisallowedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LicenseDowngradeDisallowedFault") + kw["aname"] = "_LicenseDowngradeDisallowedFault" + if ns0.LicenseDowngradeDisallowed_Def not in ns0.LicenseDowngradeDisallowedFault_Dec.__bases__: + bases = list(ns0.LicenseDowngradeDisallowedFault_Dec.__bases__) + bases.insert(0, ns0.LicenseDowngradeDisallowed_Def) + ns0.LicenseDowngradeDisallowedFault_Dec.__bases__ = tuple(bases) + + ns0.LicenseDowngradeDisallowed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LicenseDowngradeDisallowedFault_Dec_Holder" + + class LicenseExpiredFault_Dec(ElementDeclaration): + literal = "LicenseExpiredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LicenseExpiredFault") + kw["aname"] = "_LicenseExpiredFault" + if ns0.LicenseExpired_Def not in ns0.LicenseExpiredFault_Dec.__bases__: + bases = list(ns0.LicenseExpiredFault_Dec.__bases__) + bases.insert(0, ns0.LicenseExpired_Def) + ns0.LicenseExpiredFault_Dec.__bases__ = tuple(bases) + + ns0.LicenseExpired_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LicenseExpiredFault_Dec_Holder" + + class LicenseKeyEntityMismatchFault_Dec(ElementDeclaration): + literal = "LicenseKeyEntityMismatchFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LicenseKeyEntityMismatchFault") + kw["aname"] = "_LicenseKeyEntityMismatchFault" + if ns0.LicenseKeyEntityMismatch_Def not in ns0.LicenseKeyEntityMismatchFault_Dec.__bases__: + bases = list(ns0.LicenseKeyEntityMismatchFault_Dec.__bases__) + bases.insert(0, ns0.LicenseKeyEntityMismatch_Def) + ns0.LicenseKeyEntityMismatchFault_Dec.__bases__ = tuple(bases) + + ns0.LicenseKeyEntityMismatch_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LicenseKeyEntityMismatchFault_Dec_Holder" + + class LicenseRestrictedFault_Dec(ElementDeclaration): + literal = "LicenseRestrictedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LicenseRestrictedFault") + kw["aname"] = "_LicenseRestrictedFault" + if ns0.LicenseRestricted_Def not in ns0.LicenseRestrictedFault_Dec.__bases__: + bases = list(ns0.LicenseRestrictedFault_Dec.__bases__) + bases.insert(0, ns0.LicenseRestricted_Def) + ns0.LicenseRestrictedFault_Dec.__bases__ = tuple(bases) + + ns0.LicenseRestricted_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LicenseRestrictedFault_Dec_Holder" + + class LicenseServerUnavailableFault_Dec(ElementDeclaration): + literal = "LicenseServerUnavailableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LicenseServerUnavailableFault") + kw["aname"] = "_LicenseServerUnavailableFault" + if ns0.LicenseServerUnavailable_Def not in ns0.LicenseServerUnavailableFault_Dec.__bases__: + bases = list(ns0.LicenseServerUnavailableFault_Dec.__bases__) + bases.insert(0, ns0.LicenseServerUnavailable_Def) + ns0.LicenseServerUnavailableFault_Dec.__bases__ = tuple(bases) + + ns0.LicenseServerUnavailable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LicenseServerUnavailableFault_Dec_Holder" + + class LicenseSourceUnavailableFault_Dec(ElementDeclaration): + literal = "LicenseSourceUnavailableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LicenseSourceUnavailableFault") + kw["aname"] = "_LicenseSourceUnavailableFault" + if ns0.LicenseSourceUnavailable_Def not in ns0.LicenseSourceUnavailableFault_Dec.__bases__: + bases = list(ns0.LicenseSourceUnavailableFault_Dec.__bases__) + bases.insert(0, ns0.LicenseSourceUnavailable_Def) + ns0.LicenseSourceUnavailableFault_Dec.__bases__ = tuple(bases) + + ns0.LicenseSourceUnavailable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LicenseSourceUnavailableFault_Dec_Holder" + + class LimitExceededFault_Dec(ElementDeclaration): + literal = "LimitExceededFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LimitExceededFault") + kw["aname"] = "_LimitExceededFault" + if ns0.LimitExceeded_Def not in ns0.LimitExceededFault_Dec.__bases__: + bases = list(ns0.LimitExceededFault_Dec.__bases__) + bases.insert(0, ns0.LimitExceeded_Def) + ns0.LimitExceededFault_Dec.__bases__ = tuple(bases) + + ns0.LimitExceeded_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LimitExceededFault_Dec_Holder" + + class LinuxVolumeNotCleanFault_Dec(ElementDeclaration): + literal = "LinuxVolumeNotCleanFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LinuxVolumeNotCleanFault") + kw["aname"] = "_LinuxVolumeNotCleanFault" + if ns0.LinuxVolumeNotClean_Def not in ns0.LinuxVolumeNotCleanFault_Dec.__bases__: + bases = list(ns0.LinuxVolumeNotCleanFault_Dec.__bases__) + bases.insert(0, ns0.LinuxVolumeNotClean_Def) + ns0.LinuxVolumeNotCleanFault_Dec.__bases__ = tuple(bases) + + ns0.LinuxVolumeNotClean_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LinuxVolumeNotCleanFault_Dec_Holder" + + class LogBundlingFailedFault_Dec(ElementDeclaration): + literal = "LogBundlingFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","LogBundlingFailedFault") + kw["aname"] = "_LogBundlingFailedFault" + if ns0.LogBundlingFailed_Def not in ns0.LogBundlingFailedFault_Dec.__bases__: + bases = list(ns0.LogBundlingFailedFault_Dec.__bases__) + bases.insert(0, ns0.LogBundlingFailed_Def) + ns0.LogBundlingFailedFault_Dec.__bases__ = tuple(bases) + + ns0.LogBundlingFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "LogBundlingFailedFault_Dec_Holder" + + class MaintenanceModeFileMoveFault_Dec(ElementDeclaration): + literal = "MaintenanceModeFileMoveFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MaintenanceModeFileMoveFault") + kw["aname"] = "_MaintenanceModeFileMoveFault" + if ns0.MaintenanceModeFileMove_Def not in ns0.MaintenanceModeFileMoveFault_Dec.__bases__: + bases = list(ns0.MaintenanceModeFileMoveFault_Dec.__bases__) + bases.insert(0, ns0.MaintenanceModeFileMove_Def) + ns0.MaintenanceModeFileMoveFault_Dec.__bases__ = tuple(bases) + + ns0.MaintenanceModeFileMove_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MaintenanceModeFileMoveFault_Dec_Holder" + + class MemoryHotPlugNotSupportedFault_Dec(ElementDeclaration): + literal = "MemoryHotPlugNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MemoryHotPlugNotSupportedFault") + kw["aname"] = "_MemoryHotPlugNotSupportedFault" + if ns0.MemoryHotPlugNotSupported_Def not in ns0.MemoryHotPlugNotSupportedFault_Dec.__bases__: + bases = list(ns0.MemoryHotPlugNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.MemoryHotPlugNotSupported_Def) + ns0.MemoryHotPlugNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.MemoryHotPlugNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MemoryHotPlugNotSupportedFault_Dec_Holder" + + class MemorySizeNotRecommendedFault_Dec(ElementDeclaration): + literal = "MemorySizeNotRecommendedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MemorySizeNotRecommendedFault") + kw["aname"] = "_MemorySizeNotRecommendedFault" + if ns0.MemorySizeNotRecommended_Def not in ns0.MemorySizeNotRecommendedFault_Dec.__bases__: + bases = list(ns0.MemorySizeNotRecommendedFault_Dec.__bases__) + bases.insert(0, ns0.MemorySizeNotRecommended_Def) + ns0.MemorySizeNotRecommendedFault_Dec.__bases__ = tuple(bases) + + ns0.MemorySizeNotRecommended_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MemorySizeNotRecommendedFault_Dec_Holder" + + class MemorySizeNotSupportedFault_Dec(ElementDeclaration): + literal = "MemorySizeNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MemorySizeNotSupportedFault") + kw["aname"] = "_MemorySizeNotSupportedFault" + if ns0.MemorySizeNotSupported_Def not in ns0.MemorySizeNotSupportedFault_Dec.__bases__: + bases = list(ns0.MemorySizeNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.MemorySizeNotSupported_Def) + ns0.MemorySizeNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.MemorySizeNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MemorySizeNotSupportedFault_Dec_Holder" + + class MemorySnapshotOnIndependentDiskFault_Dec(ElementDeclaration): + literal = "MemorySnapshotOnIndependentDiskFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MemorySnapshotOnIndependentDiskFault") + kw["aname"] = "_MemorySnapshotOnIndependentDiskFault" + if ns0.MemorySnapshotOnIndependentDisk_Def not in ns0.MemorySnapshotOnIndependentDiskFault_Dec.__bases__: + bases = list(ns0.MemorySnapshotOnIndependentDiskFault_Dec.__bases__) + bases.insert(0, ns0.MemorySnapshotOnIndependentDisk_Def) + ns0.MemorySnapshotOnIndependentDiskFault_Dec.__bases__ = tuple(bases) + + ns0.MemorySnapshotOnIndependentDisk_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MemorySnapshotOnIndependentDiskFault_Dec_Holder" + + class MethodDisabledFault_Dec(ElementDeclaration): + literal = "MethodDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MethodDisabledFault") + kw["aname"] = "_MethodDisabledFault" + if ns0.MethodDisabled_Def not in ns0.MethodDisabledFault_Dec.__bases__: + bases = list(ns0.MethodDisabledFault_Dec.__bases__) + bases.insert(0, ns0.MethodDisabled_Def) + ns0.MethodDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.MethodDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MethodDisabledFault_Dec_Holder" + + class MigrationDisabledFault_Dec(ElementDeclaration): + literal = "MigrationDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MigrationDisabledFault") + kw["aname"] = "_MigrationDisabledFault" + if ns0.MigrationDisabled_Def not in ns0.MigrationDisabledFault_Dec.__bases__: + bases = list(ns0.MigrationDisabledFault_Dec.__bases__) + bases.insert(0, ns0.MigrationDisabled_Def) + ns0.MigrationDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.MigrationDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MigrationDisabledFault_Dec_Holder" + + class MigrationFaultFault_Dec(ElementDeclaration): + literal = "MigrationFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MigrationFaultFault") + kw["aname"] = "_MigrationFaultFault" + if ns0.MigrationFault_Def not in ns0.MigrationFaultFault_Dec.__bases__: + bases = list(ns0.MigrationFaultFault_Dec.__bases__) + bases.insert(0, ns0.MigrationFault_Def) + ns0.MigrationFaultFault_Dec.__bases__ = tuple(bases) + + ns0.MigrationFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MigrationFaultFault_Dec_Holder" + + class MigrationFeatureNotSupportedFault_Dec(ElementDeclaration): + literal = "MigrationFeatureNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MigrationFeatureNotSupportedFault") + kw["aname"] = "_MigrationFeatureNotSupportedFault" + if ns0.MigrationFeatureNotSupported_Def not in ns0.MigrationFeatureNotSupportedFault_Dec.__bases__: + bases = list(ns0.MigrationFeatureNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.MigrationFeatureNotSupported_Def) + ns0.MigrationFeatureNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.MigrationFeatureNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MigrationFeatureNotSupportedFault_Dec_Holder" + + class MigrationNotReadyFault_Dec(ElementDeclaration): + literal = "MigrationNotReadyFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MigrationNotReadyFault") + kw["aname"] = "_MigrationNotReadyFault" + if ns0.MigrationNotReady_Def not in ns0.MigrationNotReadyFault_Dec.__bases__: + bases = list(ns0.MigrationNotReadyFault_Dec.__bases__) + bases.insert(0, ns0.MigrationNotReady_Def) + ns0.MigrationNotReadyFault_Dec.__bases__ = tuple(bases) + + ns0.MigrationNotReady_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MigrationNotReadyFault_Dec_Holder" + + class MismatchedBundleFault_Dec(ElementDeclaration): + literal = "MismatchedBundleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MismatchedBundleFault") + kw["aname"] = "_MismatchedBundleFault" + if ns0.MismatchedBundle_Def not in ns0.MismatchedBundleFault_Dec.__bases__: + bases = list(ns0.MismatchedBundleFault_Dec.__bases__) + bases.insert(0, ns0.MismatchedBundle_Def) + ns0.MismatchedBundleFault_Dec.__bases__ = tuple(bases) + + ns0.MismatchedBundle_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MismatchedBundleFault_Dec_Holder" + + class MismatchedNetworkPoliciesFault_Dec(ElementDeclaration): + literal = "MismatchedNetworkPoliciesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MismatchedNetworkPoliciesFault") + kw["aname"] = "_MismatchedNetworkPoliciesFault" + if ns0.MismatchedNetworkPolicies_Def not in ns0.MismatchedNetworkPoliciesFault_Dec.__bases__: + bases = list(ns0.MismatchedNetworkPoliciesFault_Dec.__bases__) + bases.insert(0, ns0.MismatchedNetworkPolicies_Def) + ns0.MismatchedNetworkPoliciesFault_Dec.__bases__ = tuple(bases) + + ns0.MismatchedNetworkPolicies_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MismatchedNetworkPoliciesFault_Dec_Holder" + + class MismatchedVMotionNetworkNamesFault_Dec(ElementDeclaration): + literal = "MismatchedVMotionNetworkNamesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MismatchedVMotionNetworkNamesFault") + kw["aname"] = "_MismatchedVMotionNetworkNamesFault" + if ns0.MismatchedVMotionNetworkNames_Def not in ns0.MismatchedVMotionNetworkNamesFault_Dec.__bases__: + bases = list(ns0.MismatchedVMotionNetworkNamesFault_Dec.__bases__) + bases.insert(0, ns0.MismatchedVMotionNetworkNames_Def) + ns0.MismatchedVMotionNetworkNamesFault_Dec.__bases__ = tuple(bases) + + ns0.MismatchedVMotionNetworkNames_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MismatchedVMotionNetworkNamesFault_Dec_Holder" + + class MissingBmcSupportFault_Dec(ElementDeclaration): + literal = "MissingBmcSupportFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MissingBmcSupportFault") + kw["aname"] = "_MissingBmcSupportFault" + if ns0.MissingBmcSupport_Def not in ns0.MissingBmcSupportFault_Dec.__bases__: + bases = list(ns0.MissingBmcSupportFault_Dec.__bases__) + bases.insert(0, ns0.MissingBmcSupport_Def) + ns0.MissingBmcSupportFault_Dec.__bases__ = tuple(bases) + + ns0.MissingBmcSupport_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MissingBmcSupportFault_Dec_Holder" + + class MissingControllerFault_Dec(ElementDeclaration): + literal = "MissingControllerFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MissingControllerFault") + kw["aname"] = "_MissingControllerFault" + if ns0.MissingController_Def not in ns0.MissingControllerFault_Dec.__bases__: + bases = list(ns0.MissingControllerFault_Dec.__bases__) + bases.insert(0, ns0.MissingController_Def) + ns0.MissingControllerFault_Dec.__bases__ = tuple(bases) + + ns0.MissingController_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MissingControllerFault_Dec_Holder" + + class MissingLinuxCustResourcesFault_Dec(ElementDeclaration): + literal = "MissingLinuxCustResourcesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MissingLinuxCustResourcesFault") + kw["aname"] = "_MissingLinuxCustResourcesFault" + if ns0.MissingLinuxCustResources_Def not in ns0.MissingLinuxCustResourcesFault_Dec.__bases__: + bases = list(ns0.MissingLinuxCustResourcesFault_Dec.__bases__) + bases.insert(0, ns0.MissingLinuxCustResources_Def) + ns0.MissingLinuxCustResourcesFault_Dec.__bases__ = tuple(bases) + + ns0.MissingLinuxCustResources_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MissingLinuxCustResourcesFault_Dec_Holder" + + class MissingNetworkIpConfigFault_Dec(ElementDeclaration): + literal = "MissingNetworkIpConfigFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MissingNetworkIpConfigFault") + kw["aname"] = "_MissingNetworkIpConfigFault" + if ns0.MissingNetworkIpConfig_Def not in ns0.MissingNetworkIpConfigFault_Dec.__bases__: + bases = list(ns0.MissingNetworkIpConfigFault_Dec.__bases__) + bases.insert(0, ns0.MissingNetworkIpConfig_Def) + ns0.MissingNetworkIpConfigFault_Dec.__bases__ = tuple(bases) + + ns0.MissingNetworkIpConfig_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MissingNetworkIpConfigFault_Dec_Holder" + + class MissingPowerOffConfigurationFault_Dec(ElementDeclaration): + literal = "MissingPowerOffConfigurationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MissingPowerOffConfigurationFault") + kw["aname"] = "_MissingPowerOffConfigurationFault" + if ns0.MissingPowerOffConfiguration_Def not in ns0.MissingPowerOffConfigurationFault_Dec.__bases__: + bases = list(ns0.MissingPowerOffConfigurationFault_Dec.__bases__) + bases.insert(0, ns0.MissingPowerOffConfiguration_Def) + ns0.MissingPowerOffConfigurationFault_Dec.__bases__ = tuple(bases) + + ns0.MissingPowerOffConfiguration_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MissingPowerOffConfigurationFault_Dec_Holder" + + class MissingPowerOnConfigurationFault_Dec(ElementDeclaration): + literal = "MissingPowerOnConfigurationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MissingPowerOnConfigurationFault") + kw["aname"] = "_MissingPowerOnConfigurationFault" + if ns0.MissingPowerOnConfiguration_Def not in ns0.MissingPowerOnConfigurationFault_Dec.__bases__: + bases = list(ns0.MissingPowerOnConfigurationFault_Dec.__bases__) + bases.insert(0, ns0.MissingPowerOnConfiguration_Def) + ns0.MissingPowerOnConfigurationFault_Dec.__bases__ = tuple(bases) + + ns0.MissingPowerOnConfiguration_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MissingPowerOnConfigurationFault_Dec_Holder" + + class MissingWindowsCustResourcesFault_Dec(ElementDeclaration): + literal = "MissingWindowsCustResourcesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MissingWindowsCustResourcesFault") + kw["aname"] = "_MissingWindowsCustResourcesFault" + if ns0.MissingWindowsCustResources_Def not in ns0.MissingWindowsCustResourcesFault_Dec.__bases__: + bases = list(ns0.MissingWindowsCustResourcesFault_Dec.__bases__) + bases.insert(0, ns0.MissingWindowsCustResources_Def) + ns0.MissingWindowsCustResourcesFault_Dec.__bases__ = tuple(bases) + + ns0.MissingWindowsCustResources_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MissingWindowsCustResourcesFault_Dec_Holder" + + class MountErrorFault_Dec(ElementDeclaration): + literal = "MountErrorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MountErrorFault") + kw["aname"] = "_MountErrorFault" + if ns0.MountError_Def not in ns0.MountErrorFault_Dec.__bases__: + bases = list(ns0.MountErrorFault_Dec.__bases__) + bases.insert(0, ns0.MountError_Def) + ns0.MountErrorFault_Dec.__bases__ = tuple(bases) + + ns0.MountError_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MountErrorFault_Dec_Holder" + + class MultipleCertificatesVerifyFaultFault_Dec(ElementDeclaration): + literal = "MultipleCertificatesVerifyFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MultipleCertificatesVerifyFaultFault") + kw["aname"] = "_MultipleCertificatesVerifyFaultFault" + if ns0.MultipleCertificatesVerifyFault_Def not in ns0.MultipleCertificatesVerifyFaultFault_Dec.__bases__: + bases = list(ns0.MultipleCertificatesVerifyFaultFault_Dec.__bases__) + bases.insert(0, ns0.MultipleCertificatesVerifyFault_Def) + ns0.MultipleCertificatesVerifyFaultFault_Dec.__bases__ = tuple(bases) + + ns0.MultipleCertificatesVerifyFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MultipleCertificatesVerifyFaultFault_Dec_Holder" + + class MultipleSnapshotsNotSupportedFault_Dec(ElementDeclaration): + literal = "MultipleSnapshotsNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","MultipleSnapshotsNotSupportedFault") + kw["aname"] = "_MultipleSnapshotsNotSupportedFault" + if ns0.MultipleSnapshotsNotSupported_Def not in ns0.MultipleSnapshotsNotSupportedFault_Dec.__bases__: + bases = list(ns0.MultipleSnapshotsNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.MultipleSnapshotsNotSupported_Def) + ns0.MultipleSnapshotsNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.MultipleSnapshotsNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "MultipleSnapshotsNotSupportedFault_Dec_Holder" + + class NasConfigFaultFault_Dec(ElementDeclaration): + literal = "NasConfigFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NasConfigFaultFault") + kw["aname"] = "_NasConfigFaultFault" + if ns0.NasConfigFault_Def not in ns0.NasConfigFaultFault_Dec.__bases__: + bases = list(ns0.NasConfigFaultFault_Dec.__bases__) + bases.insert(0, ns0.NasConfigFault_Def) + ns0.NasConfigFaultFault_Dec.__bases__ = tuple(bases) + + ns0.NasConfigFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NasConfigFaultFault_Dec_Holder" + + class NasConnectionLimitReachedFault_Dec(ElementDeclaration): + literal = "NasConnectionLimitReachedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NasConnectionLimitReachedFault") + kw["aname"] = "_NasConnectionLimitReachedFault" + if ns0.NasConnectionLimitReached_Def not in ns0.NasConnectionLimitReachedFault_Dec.__bases__: + bases = list(ns0.NasConnectionLimitReachedFault_Dec.__bases__) + bases.insert(0, ns0.NasConnectionLimitReached_Def) + ns0.NasConnectionLimitReachedFault_Dec.__bases__ = tuple(bases) + + ns0.NasConnectionLimitReached_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NasConnectionLimitReachedFault_Dec_Holder" + + class NasSessionCredentialConflictFault_Dec(ElementDeclaration): + literal = "NasSessionCredentialConflictFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NasSessionCredentialConflictFault") + kw["aname"] = "_NasSessionCredentialConflictFault" + if ns0.NasSessionCredentialConflict_Def not in ns0.NasSessionCredentialConflictFault_Dec.__bases__: + bases = list(ns0.NasSessionCredentialConflictFault_Dec.__bases__) + bases.insert(0, ns0.NasSessionCredentialConflict_Def) + ns0.NasSessionCredentialConflictFault_Dec.__bases__ = tuple(bases) + + ns0.NasSessionCredentialConflict_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NasSessionCredentialConflictFault_Dec_Holder" + + class NasVolumeNotMountedFault_Dec(ElementDeclaration): + literal = "NasVolumeNotMountedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NasVolumeNotMountedFault") + kw["aname"] = "_NasVolumeNotMountedFault" + if ns0.NasVolumeNotMounted_Def not in ns0.NasVolumeNotMountedFault_Dec.__bases__: + bases = list(ns0.NasVolumeNotMountedFault_Dec.__bases__) + bases.insert(0, ns0.NasVolumeNotMounted_Def) + ns0.NasVolumeNotMountedFault_Dec.__bases__ = tuple(bases) + + ns0.NasVolumeNotMounted_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NasVolumeNotMountedFault_Dec_Holder" + + class NetworkCopyFaultFault_Dec(ElementDeclaration): + literal = "NetworkCopyFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NetworkCopyFaultFault") + kw["aname"] = "_NetworkCopyFaultFault" + if ns0.NetworkCopyFault_Def not in ns0.NetworkCopyFaultFault_Dec.__bases__: + bases = list(ns0.NetworkCopyFaultFault_Dec.__bases__) + bases.insert(0, ns0.NetworkCopyFault_Def) + ns0.NetworkCopyFaultFault_Dec.__bases__ = tuple(bases) + + ns0.NetworkCopyFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NetworkCopyFaultFault_Dec_Holder" + + class NetworkInaccessibleFault_Dec(ElementDeclaration): + literal = "NetworkInaccessibleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NetworkInaccessibleFault") + kw["aname"] = "_NetworkInaccessibleFault" + if ns0.NetworkInaccessible_Def not in ns0.NetworkInaccessibleFault_Dec.__bases__: + bases = list(ns0.NetworkInaccessibleFault_Dec.__bases__) + bases.insert(0, ns0.NetworkInaccessible_Def) + ns0.NetworkInaccessibleFault_Dec.__bases__ = tuple(bases) + + ns0.NetworkInaccessible_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NetworkInaccessibleFault_Dec_Holder" + + class NetworksMayNotBeTheSameFault_Dec(ElementDeclaration): + literal = "NetworksMayNotBeTheSameFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NetworksMayNotBeTheSameFault") + kw["aname"] = "_NetworksMayNotBeTheSameFault" + if ns0.NetworksMayNotBeTheSame_Def not in ns0.NetworksMayNotBeTheSameFault_Dec.__bases__: + bases = list(ns0.NetworksMayNotBeTheSameFault_Dec.__bases__) + bases.insert(0, ns0.NetworksMayNotBeTheSame_Def) + ns0.NetworksMayNotBeTheSameFault_Dec.__bases__ = tuple(bases) + + ns0.NetworksMayNotBeTheSame_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NetworksMayNotBeTheSameFault_Dec_Holder" + + class NicSettingMismatchFault_Dec(ElementDeclaration): + literal = "NicSettingMismatchFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NicSettingMismatchFault") + kw["aname"] = "_NicSettingMismatchFault" + if ns0.NicSettingMismatch_Def not in ns0.NicSettingMismatchFault_Dec.__bases__: + bases = list(ns0.NicSettingMismatchFault_Dec.__bases__) + bases.insert(0, ns0.NicSettingMismatch_Def) + ns0.NicSettingMismatchFault_Dec.__bases__ = tuple(bases) + + ns0.NicSettingMismatch_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NicSettingMismatchFault_Dec_Holder" + + class NoActiveHostInClusterFault_Dec(ElementDeclaration): + literal = "NoActiveHostInClusterFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoActiveHostInClusterFault") + kw["aname"] = "_NoActiveHostInClusterFault" + if ns0.NoActiveHostInCluster_Def not in ns0.NoActiveHostInClusterFault_Dec.__bases__: + bases = list(ns0.NoActiveHostInClusterFault_Dec.__bases__) + bases.insert(0, ns0.NoActiveHostInCluster_Def) + ns0.NoActiveHostInClusterFault_Dec.__bases__ = tuple(bases) + + ns0.NoActiveHostInCluster_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoActiveHostInClusterFault_Dec_Holder" + + class NoAvailableIpFault_Dec(ElementDeclaration): + literal = "NoAvailableIpFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoAvailableIpFault") + kw["aname"] = "_NoAvailableIpFault" + if ns0.NoAvailableIp_Def not in ns0.NoAvailableIpFault_Dec.__bases__: + bases = list(ns0.NoAvailableIpFault_Dec.__bases__) + bases.insert(0, ns0.NoAvailableIp_Def) + ns0.NoAvailableIpFault_Dec.__bases__ = tuple(bases) + + ns0.NoAvailableIp_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoAvailableIpFault_Dec_Holder" + + class NoClientCertificateFault_Dec(ElementDeclaration): + literal = "NoClientCertificateFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoClientCertificateFault") + kw["aname"] = "_NoClientCertificateFault" + if ns0.NoClientCertificate_Def not in ns0.NoClientCertificateFault_Dec.__bases__: + bases = list(ns0.NoClientCertificateFault_Dec.__bases__) + bases.insert(0, ns0.NoClientCertificate_Def) + ns0.NoClientCertificateFault_Dec.__bases__ = tuple(bases) + + ns0.NoClientCertificate_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoClientCertificateFault_Dec_Holder" + + class NoCompatibleHostFault_Dec(ElementDeclaration): + literal = "NoCompatibleHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoCompatibleHostFault") + kw["aname"] = "_NoCompatibleHostFault" + if ns0.NoCompatibleHost_Def not in ns0.NoCompatibleHostFault_Dec.__bases__: + bases = list(ns0.NoCompatibleHostFault_Dec.__bases__) + bases.insert(0, ns0.NoCompatibleHost_Def) + ns0.NoCompatibleHostFault_Dec.__bases__ = tuple(bases) + + ns0.NoCompatibleHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoCompatibleHostFault_Dec_Holder" + + class NoDiskFoundFault_Dec(ElementDeclaration): + literal = "NoDiskFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoDiskFoundFault") + kw["aname"] = "_NoDiskFoundFault" + if ns0.NoDiskFound_Def not in ns0.NoDiskFoundFault_Dec.__bases__: + bases = list(ns0.NoDiskFoundFault_Dec.__bases__) + bases.insert(0, ns0.NoDiskFound_Def) + ns0.NoDiskFoundFault_Dec.__bases__ = tuple(bases) + + ns0.NoDiskFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoDiskFoundFault_Dec_Holder" + + class NoDiskSpaceFault_Dec(ElementDeclaration): + literal = "NoDiskSpaceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoDiskSpaceFault") + kw["aname"] = "_NoDiskSpaceFault" + if ns0.NoDiskSpace_Def not in ns0.NoDiskSpaceFault_Dec.__bases__: + bases = list(ns0.NoDiskSpaceFault_Dec.__bases__) + bases.insert(0, ns0.NoDiskSpace_Def) + ns0.NoDiskSpaceFault_Dec.__bases__ = tuple(bases) + + ns0.NoDiskSpace_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoDiskSpaceFault_Dec_Holder" + + class NoDisksToCustomizeFault_Dec(ElementDeclaration): + literal = "NoDisksToCustomizeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoDisksToCustomizeFault") + kw["aname"] = "_NoDisksToCustomizeFault" + if ns0.NoDisksToCustomize_Def not in ns0.NoDisksToCustomizeFault_Dec.__bases__: + bases = list(ns0.NoDisksToCustomizeFault_Dec.__bases__) + bases.insert(0, ns0.NoDisksToCustomize_Def) + ns0.NoDisksToCustomizeFault_Dec.__bases__ = tuple(bases) + + ns0.NoDisksToCustomize_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoDisksToCustomizeFault_Dec_Holder" + + class NoGatewayFault_Dec(ElementDeclaration): + literal = "NoGatewayFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoGatewayFault") + kw["aname"] = "_NoGatewayFault" + if ns0.NoGateway_Def not in ns0.NoGatewayFault_Dec.__bases__: + bases = list(ns0.NoGatewayFault_Dec.__bases__) + bases.insert(0, ns0.NoGateway_Def) + ns0.NoGatewayFault_Dec.__bases__ = tuple(bases) + + ns0.NoGateway_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoGatewayFault_Dec_Holder" + + class NoGuestHeartbeatFault_Dec(ElementDeclaration): + literal = "NoGuestHeartbeatFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoGuestHeartbeatFault") + kw["aname"] = "_NoGuestHeartbeatFault" + if ns0.NoGuestHeartbeat_Def not in ns0.NoGuestHeartbeatFault_Dec.__bases__: + bases = list(ns0.NoGuestHeartbeatFault_Dec.__bases__) + bases.insert(0, ns0.NoGuestHeartbeat_Def) + ns0.NoGuestHeartbeatFault_Dec.__bases__ = tuple(bases) + + ns0.NoGuestHeartbeat_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoGuestHeartbeatFault_Dec_Holder" + + class NoHostFault_Dec(ElementDeclaration): + literal = "NoHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoHostFault") + kw["aname"] = "_NoHostFault" + if ns0.NoHost_Def not in ns0.NoHostFault_Dec.__bases__: + bases = list(ns0.NoHostFault_Dec.__bases__) + bases.insert(0, ns0.NoHost_Def) + ns0.NoHostFault_Dec.__bases__ = tuple(bases) + + ns0.NoHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoHostFault_Dec_Holder" + + class NoHostSuitableForFtSecondaryFault_Dec(ElementDeclaration): + literal = "NoHostSuitableForFtSecondaryFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoHostSuitableForFtSecondaryFault") + kw["aname"] = "_NoHostSuitableForFtSecondaryFault" + if ns0.NoHostSuitableForFtSecondary_Def not in ns0.NoHostSuitableForFtSecondaryFault_Dec.__bases__: + bases = list(ns0.NoHostSuitableForFtSecondaryFault_Dec.__bases__) + bases.insert(0, ns0.NoHostSuitableForFtSecondary_Def) + ns0.NoHostSuitableForFtSecondaryFault_Dec.__bases__ = tuple(bases) + + ns0.NoHostSuitableForFtSecondary_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoHostSuitableForFtSecondaryFault_Dec_Holder" + + class NoLicenseServerConfiguredFault_Dec(ElementDeclaration): + literal = "NoLicenseServerConfiguredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoLicenseServerConfiguredFault") + kw["aname"] = "_NoLicenseServerConfiguredFault" + if ns0.NoLicenseServerConfigured_Def not in ns0.NoLicenseServerConfiguredFault_Dec.__bases__: + bases = list(ns0.NoLicenseServerConfiguredFault_Dec.__bases__) + bases.insert(0, ns0.NoLicenseServerConfigured_Def) + ns0.NoLicenseServerConfiguredFault_Dec.__bases__ = tuple(bases) + + ns0.NoLicenseServerConfigured_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoLicenseServerConfiguredFault_Dec_Holder" + + class NoPeerHostFoundFault_Dec(ElementDeclaration): + literal = "NoPeerHostFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoPeerHostFoundFault") + kw["aname"] = "_NoPeerHostFoundFault" + if ns0.NoPeerHostFound_Def not in ns0.NoPeerHostFoundFault_Dec.__bases__: + bases = list(ns0.NoPeerHostFoundFault_Dec.__bases__) + bases.insert(0, ns0.NoPeerHostFound_Def) + ns0.NoPeerHostFoundFault_Dec.__bases__ = tuple(bases) + + ns0.NoPeerHostFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoPeerHostFoundFault_Dec_Holder" + + class NoPermissionFault_Dec(ElementDeclaration): + literal = "NoPermissionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoPermissionFault") + kw["aname"] = "_NoPermissionFault" + if ns0.NoPermission_Def not in ns0.NoPermissionFault_Dec.__bases__: + bases = list(ns0.NoPermissionFault_Dec.__bases__) + bases.insert(0, ns0.NoPermission_Def) + ns0.NoPermissionFault_Dec.__bases__ = tuple(bases) + + ns0.NoPermission_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoPermissionFault_Dec_Holder" + + class NoPermissionOnHostFault_Dec(ElementDeclaration): + literal = "NoPermissionOnHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoPermissionOnHostFault") + kw["aname"] = "_NoPermissionOnHostFault" + if ns0.NoPermissionOnHost_Def not in ns0.NoPermissionOnHostFault_Dec.__bases__: + bases = list(ns0.NoPermissionOnHostFault_Dec.__bases__) + bases.insert(0, ns0.NoPermissionOnHost_Def) + ns0.NoPermissionOnHostFault_Dec.__bases__ = tuple(bases) + + ns0.NoPermissionOnHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoPermissionOnHostFault_Dec_Holder" + + class NoPermissionOnNasVolumeFault_Dec(ElementDeclaration): + literal = "NoPermissionOnNasVolumeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoPermissionOnNasVolumeFault") + kw["aname"] = "_NoPermissionOnNasVolumeFault" + if ns0.NoPermissionOnNasVolume_Def not in ns0.NoPermissionOnNasVolumeFault_Dec.__bases__: + bases = list(ns0.NoPermissionOnNasVolumeFault_Dec.__bases__) + bases.insert(0, ns0.NoPermissionOnNasVolume_Def) + ns0.NoPermissionOnNasVolumeFault_Dec.__bases__ = tuple(bases) + + ns0.NoPermissionOnNasVolume_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoPermissionOnNasVolumeFault_Dec_Holder" + + class NoSubjectNameFault_Dec(ElementDeclaration): + literal = "NoSubjectNameFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoSubjectNameFault") + kw["aname"] = "_NoSubjectNameFault" + if ns0.NoSubjectName_Def not in ns0.NoSubjectNameFault_Dec.__bases__: + bases = list(ns0.NoSubjectNameFault_Dec.__bases__) + bases.insert(0, ns0.NoSubjectName_Def) + ns0.NoSubjectNameFault_Dec.__bases__ = tuple(bases) + + ns0.NoSubjectName_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoSubjectNameFault_Dec_Holder" + + class NoVcManagedIpConfiguredFault_Dec(ElementDeclaration): + literal = "NoVcManagedIpConfiguredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoVcManagedIpConfiguredFault") + kw["aname"] = "_NoVcManagedIpConfiguredFault" + if ns0.NoVcManagedIpConfigured_Def not in ns0.NoVcManagedIpConfiguredFault_Dec.__bases__: + bases = list(ns0.NoVcManagedIpConfiguredFault_Dec.__bases__) + bases.insert(0, ns0.NoVcManagedIpConfigured_Def) + ns0.NoVcManagedIpConfiguredFault_Dec.__bases__ = tuple(bases) + + ns0.NoVcManagedIpConfigured_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoVcManagedIpConfiguredFault_Dec_Holder" + + class NoVirtualNicFault_Dec(ElementDeclaration): + literal = "NoVirtualNicFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoVirtualNicFault") + kw["aname"] = "_NoVirtualNicFault" + if ns0.NoVirtualNic_Def not in ns0.NoVirtualNicFault_Dec.__bases__: + bases = list(ns0.NoVirtualNicFault_Dec.__bases__) + bases.insert(0, ns0.NoVirtualNic_Def) + ns0.NoVirtualNicFault_Dec.__bases__ = tuple(bases) + + ns0.NoVirtualNic_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoVirtualNicFault_Dec_Holder" + + class NoVmInVAppFault_Dec(ElementDeclaration): + literal = "NoVmInVAppFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NoVmInVAppFault") + kw["aname"] = "_NoVmInVAppFault" + if ns0.NoVmInVApp_Def not in ns0.NoVmInVAppFault_Dec.__bases__: + bases = list(ns0.NoVmInVAppFault_Dec.__bases__) + bases.insert(0, ns0.NoVmInVApp_Def) + ns0.NoVmInVAppFault_Dec.__bases__ = tuple(bases) + + ns0.NoVmInVApp_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NoVmInVAppFault_Dec_Holder" + + class NonHomeRDMVMotionNotSupportedFault_Dec(ElementDeclaration): + literal = "NonHomeRDMVMotionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NonHomeRDMVMotionNotSupportedFault") + kw["aname"] = "_NonHomeRDMVMotionNotSupportedFault" + if ns0.NonHomeRDMVMotionNotSupported_Def not in ns0.NonHomeRDMVMotionNotSupportedFault_Dec.__bases__: + bases = list(ns0.NonHomeRDMVMotionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.NonHomeRDMVMotionNotSupported_Def) + ns0.NonHomeRDMVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.NonHomeRDMVMotionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NonHomeRDMVMotionNotSupportedFault_Dec_Holder" + + class NonPersistentDisksNotSupportedFault_Dec(ElementDeclaration): + literal = "NonPersistentDisksNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NonPersistentDisksNotSupportedFault") + kw["aname"] = "_NonPersistentDisksNotSupportedFault" + if ns0.NonPersistentDisksNotSupported_Def not in ns0.NonPersistentDisksNotSupportedFault_Dec.__bases__: + bases = list(ns0.NonPersistentDisksNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.NonPersistentDisksNotSupported_Def) + ns0.NonPersistentDisksNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.NonPersistentDisksNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NonPersistentDisksNotSupportedFault_Dec_Holder" + + class NotAuthenticatedFault_Dec(ElementDeclaration): + literal = "NotAuthenticatedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotAuthenticatedFault") + kw["aname"] = "_NotAuthenticatedFault" + if ns0.NotAuthenticated_Def not in ns0.NotAuthenticatedFault_Dec.__bases__: + bases = list(ns0.NotAuthenticatedFault_Dec.__bases__) + bases.insert(0, ns0.NotAuthenticated_Def) + ns0.NotAuthenticatedFault_Dec.__bases__ = tuple(bases) + + ns0.NotAuthenticated_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotAuthenticatedFault_Dec_Holder" + + class NotEnoughCpusFault_Dec(ElementDeclaration): + literal = "NotEnoughCpusFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotEnoughCpusFault") + kw["aname"] = "_NotEnoughCpusFault" + if ns0.NotEnoughCpus_Def not in ns0.NotEnoughCpusFault_Dec.__bases__: + bases = list(ns0.NotEnoughCpusFault_Dec.__bases__) + bases.insert(0, ns0.NotEnoughCpus_Def) + ns0.NotEnoughCpusFault_Dec.__bases__ = tuple(bases) + + ns0.NotEnoughCpus_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotEnoughCpusFault_Dec_Holder" + + class NotEnoughLogicalCpusFault_Dec(ElementDeclaration): + literal = "NotEnoughLogicalCpusFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotEnoughLogicalCpusFault") + kw["aname"] = "_NotEnoughLogicalCpusFault" + if ns0.NotEnoughLogicalCpus_Def not in ns0.NotEnoughLogicalCpusFault_Dec.__bases__: + bases = list(ns0.NotEnoughLogicalCpusFault_Dec.__bases__) + bases.insert(0, ns0.NotEnoughLogicalCpus_Def) + ns0.NotEnoughLogicalCpusFault_Dec.__bases__ = tuple(bases) + + ns0.NotEnoughLogicalCpus_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotEnoughLogicalCpusFault_Dec_Holder" + + class NotFoundFault_Dec(ElementDeclaration): + literal = "NotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotFoundFault") + kw["aname"] = "_NotFoundFault" + if ns0.NotFound_Def not in ns0.NotFoundFault_Dec.__bases__: + bases = list(ns0.NotFoundFault_Dec.__bases__) + bases.insert(0, ns0.NotFound_Def) + ns0.NotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.NotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotFoundFault_Dec_Holder" + + class NotSupportedHostFault_Dec(ElementDeclaration): + literal = "NotSupportedHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotSupportedHostFault") + kw["aname"] = "_NotSupportedHostFault" + if ns0.NotSupportedHost_Def not in ns0.NotSupportedHostFault_Dec.__bases__: + bases = list(ns0.NotSupportedHostFault_Dec.__bases__) + bases.insert(0, ns0.NotSupportedHost_Def) + ns0.NotSupportedHostFault_Dec.__bases__ = tuple(bases) + + ns0.NotSupportedHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotSupportedHostFault_Dec_Holder" + + class NotSupportedHostInClusterFault_Dec(ElementDeclaration): + literal = "NotSupportedHostInClusterFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotSupportedHostInClusterFault") + kw["aname"] = "_NotSupportedHostInClusterFault" + if ns0.NotSupportedHostInCluster_Def not in ns0.NotSupportedHostInClusterFault_Dec.__bases__: + bases = list(ns0.NotSupportedHostInClusterFault_Dec.__bases__) + bases.insert(0, ns0.NotSupportedHostInCluster_Def) + ns0.NotSupportedHostInClusterFault_Dec.__bases__ = tuple(bases) + + ns0.NotSupportedHostInCluster_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotSupportedHostInClusterFault_Dec_Holder" + + class NotUserConfigurablePropertyFault_Dec(ElementDeclaration): + literal = "NotUserConfigurablePropertyFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NotUserConfigurablePropertyFault") + kw["aname"] = "_NotUserConfigurablePropertyFault" + if ns0.NotUserConfigurableProperty_Def not in ns0.NotUserConfigurablePropertyFault_Dec.__bases__: + bases = list(ns0.NotUserConfigurablePropertyFault_Dec.__bases__) + bases.insert(0, ns0.NotUserConfigurableProperty_Def) + ns0.NotUserConfigurablePropertyFault_Dec.__bases__ = tuple(bases) + + ns0.NotUserConfigurableProperty_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NotUserConfigurablePropertyFault_Dec_Holder" + + class NumVirtualCpusIncompatibleFault_Dec(ElementDeclaration): + literal = "NumVirtualCpusIncompatibleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NumVirtualCpusIncompatibleFault") + kw["aname"] = "_NumVirtualCpusIncompatibleFault" + if ns0.NumVirtualCpusIncompatible_Def not in ns0.NumVirtualCpusIncompatibleFault_Dec.__bases__: + bases = list(ns0.NumVirtualCpusIncompatibleFault_Dec.__bases__) + bases.insert(0, ns0.NumVirtualCpusIncompatible_Def) + ns0.NumVirtualCpusIncompatibleFault_Dec.__bases__ = tuple(bases) + + ns0.NumVirtualCpusIncompatible_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NumVirtualCpusIncompatibleFault_Dec_Holder" + + class NumVirtualCpusNotSupportedFault_Dec(ElementDeclaration): + literal = "NumVirtualCpusNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","NumVirtualCpusNotSupportedFault") + kw["aname"] = "_NumVirtualCpusNotSupportedFault" + if ns0.NumVirtualCpusNotSupported_Def not in ns0.NumVirtualCpusNotSupportedFault_Dec.__bases__: + bases = list(ns0.NumVirtualCpusNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.NumVirtualCpusNotSupported_Def) + ns0.NumVirtualCpusNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.NumVirtualCpusNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "NumVirtualCpusNotSupportedFault_Dec_Holder" + + class OutOfBoundsFault_Dec(ElementDeclaration): + literal = "OutOfBoundsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OutOfBoundsFault") + kw["aname"] = "_OutOfBoundsFault" + if ns0.OutOfBounds_Def not in ns0.OutOfBoundsFault_Dec.__bases__: + bases = list(ns0.OutOfBoundsFault_Dec.__bases__) + bases.insert(0, ns0.OutOfBounds_Def) + ns0.OutOfBoundsFault_Dec.__bases__ = tuple(bases) + + ns0.OutOfBounds_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OutOfBoundsFault_Dec_Holder" + + class OvfAttributeFault_Dec(ElementDeclaration): + literal = "OvfAttributeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfAttributeFault") + kw["aname"] = "_OvfAttributeFault" + if ns0.OvfAttribute_Def not in ns0.OvfAttributeFault_Dec.__bases__: + bases = list(ns0.OvfAttributeFault_Dec.__bases__) + bases.insert(0, ns0.OvfAttribute_Def) + ns0.OvfAttributeFault_Dec.__bases__ = tuple(bases) + + ns0.OvfAttribute_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfAttributeFault_Dec_Holder" + + class OvfConnectedDeviceFault_Dec(ElementDeclaration): + literal = "OvfConnectedDeviceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfConnectedDeviceFault") + kw["aname"] = "_OvfConnectedDeviceFault" + if ns0.OvfConnectedDevice_Def not in ns0.OvfConnectedDeviceFault_Dec.__bases__: + bases = list(ns0.OvfConnectedDeviceFault_Dec.__bases__) + bases.insert(0, ns0.OvfConnectedDevice_Def) + ns0.OvfConnectedDeviceFault_Dec.__bases__ = tuple(bases) + + ns0.OvfConnectedDevice_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfConnectedDeviceFault_Dec_Holder" + + class OvfConnectedDeviceFloppyFault_Dec(ElementDeclaration): + literal = "OvfConnectedDeviceFloppyFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfConnectedDeviceFloppyFault") + kw["aname"] = "_OvfConnectedDeviceFloppyFault" + if ns0.OvfConnectedDeviceFloppy_Def not in ns0.OvfConnectedDeviceFloppyFault_Dec.__bases__: + bases = list(ns0.OvfConnectedDeviceFloppyFault_Dec.__bases__) + bases.insert(0, ns0.OvfConnectedDeviceFloppy_Def) + ns0.OvfConnectedDeviceFloppyFault_Dec.__bases__ = tuple(bases) + + ns0.OvfConnectedDeviceFloppy_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfConnectedDeviceFloppyFault_Dec_Holder" + + class OvfConnectedDeviceIsoFault_Dec(ElementDeclaration): + literal = "OvfConnectedDeviceIsoFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfConnectedDeviceIsoFault") + kw["aname"] = "_OvfConnectedDeviceIsoFault" + if ns0.OvfConnectedDeviceIso_Def not in ns0.OvfConnectedDeviceIsoFault_Dec.__bases__: + bases = list(ns0.OvfConnectedDeviceIsoFault_Dec.__bases__) + bases.insert(0, ns0.OvfConnectedDeviceIso_Def) + ns0.OvfConnectedDeviceIsoFault_Dec.__bases__ = tuple(bases) + + ns0.OvfConnectedDeviceIso_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfConnectedDeviceIsoFault_Dec_Holder" + + class OvfDiskMappingNotFoundFault_Dec(ElementDeclaration): + literal = "OvfDiskMappingNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfDiskMappingNotFoundFault") + kw["aname"] = "_OvfDiskMappingNotFoundFault" + if ns0.OvfDiskMappingNotFound_Def not in ns0.OvfDiskMappingNotFoundFault_Dec.__bases__: + bases = list(ns0.OvfDiskMappingNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.OvfDiskMappingNotFound_Def) + ns0.OvfDiskMappingNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.OvfDiskMappingNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfDiskMappingNotFoundFault_Dec_Holder" + + class OvfDuplicateElementFault_Dec(ElementDeclaration): + literal = "OvfDuplicateElementFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfDuplicateElementFault") + kw["aname"] = "_OvfDuplicateElementFault" + if ns0.OvfDuplicateElement_Def not in ns0.OvfDuplicateElementFault_Dec.__bases__: + bases = list(ns0.OvfDuplicateElementFault_Dec.__bases__) + bases.insert(0, ns0.OvfDuplicateElement_Def) + ns0.OvfDuplicateElementFault_Dec.__bases__ = tuple(bases) + + ns0.OvfDuplicateElement_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfDuplicateElementFault_Dec_Holder" + + class OvfDuplicatedElementBoundaryFault_Dec(ElementDeclaration): + literal = "OvfDuplicatedElementBoundaryFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfDuplicatedElementBoundaryFault") + kw["aname"] = "_OvfDuplicatedElementBoundaryFault" + if ns0.OvfDuplicatedElementBoundary_Def not in ns0.OvfDuplicatedElementBoundaryFault_Dec.__bases__: + bases = list(ns0.OvfDuplicatedElementBoundaryFault_Dec.__bases__) + bases.insert(0, ns0.OvfDuplicatedElementBoundary_Def) + ns0.OvfDuplicatedElementBoundaryFault_Dec.__bases__ = tuple(bases) + + ns0.OvfDuplicatedElementBoundary_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfDuplicatedElementBoundaryFault_Dec_Holder" + + class OvfElementFault_Dec(ElementDeclaration): + literal = "OvfElementFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfElementFault") + kw["aname"] = "_OvfElementFault" + if ns0.OvfElement_Def not in ns0.OvfElementFault_Dec.__bases__: + bases = list(ns0.OvfElementFault_Dec.__bases__) + bases.insert(0, ns0.OvfElement_Def) + ns0.OvfElementFault_Dec.__bases__ = tuple(bases) + + ns0.OvfElement_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfElementFault_Dec_Holder" + + class OvfElementInvalidValueFault_Dec(ElementDeclaration): + literal = "OvfElementInvalidValueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfElementInvalidValueFault") + kw["aname"] = "_OvfElementInvalidValueFault" + if ns0.OvfElementInvalidValue_Def not in ns0.OvfElementInvalidValueFault_Dec.__bases__: + bases = list(ns0.OvfElementInvalidValueFault_Dec.__bases__) + bases.insert(0, ns0.OvfElementInvalidValue_Def) + ns0.OvfElementInvalidValueFault_Dec.__bases__ = tuple(bases) + + ns0.OvfElementInvalidValue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfElementInvalidValueFault_Dec_Holder" + + class OvfExportFault_Dec(ElementDeclaration): + literal = "OvfExportFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfExportFault") + kw["aname"] = "_OvfExportFault" + if ns0.OvfExport_Def not in ns0.OvfExportFault_Dec.__bases__: + bases = list(ns0.OvfExportFault_Dec.__bases__) + bases.insert(0, ns0.OvfExport_Def) + ns0.OvfExportFault_Dec.__bases__ = tuple(bases) + + ns0.OvfExport_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfExportFault_Dec_Holder" + + class OvfFaultFault_Dec(ElementDeclaration): + literal = "OvfFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfFaultFault") + kw["aname"] = "_OvfFaultFault" + if ns0.OvfFault_Def not in ns0.OvfFaultFault_Dec.__bases__: + bases = list(ns0.OvfFaultFault_Dec.__bases__) + bases.insert(0, ns0.OvfFault_Def) + ns0.OvfFaultFault_Dec.__bases__ = tuple(bases) + + ns0.OvfFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfFaultFault_Dec_Holder" + + class OvfHardwareCheckFault_Dec(ElementDeclaration): + literal = "OvfHardwareCheckFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfHardwareCheckFault") + kw["aname"] = "_OvfHardwareCheckFault" + if ns0.OvfHardwareCheck_Def not in ns0.OvfHardwareCheckFault_Dec.__bases__: + bases = list(ns0.OvfHardwareCheckFault_Dec.__bases__) + bases.insert(0, ns0.OvfHardwareCheck_Def) + ns0.OvfHardwareCheckFault_Dec.__bases__ = tuple(bases) + + ns0.OvfHardwareCheck_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfHardwareCheckFault_Dec_Holder" + + class OvfHardwareExportFault_Dec(ElementDeclaration): + literal = "OvfHardwareExportFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfHardwareExportFault") + kw["aname"] = "_OvfHardwareExportFault" + if ns0.OvfHardwareExport_Def not in ns0.OvfHardwareExportFault_Dec.__bases__: + bases = list(ns0.OvfHardwareExportFault_Dec.__bases__) + bases.insert(0, ns0.OvfHardwareExport_Def) + ns0.OvfHardwareExportFault_Dec.__bases__ = tuple(bases) + + ns0.OvfHardwareExport_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfHardwareExportFault_Dec_Holder" + + class OvfHostValueNotParsedFault_Dec(ElementDeclaration): + literal = "OvfHostValueNotParsedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfHostValueNotParsedFault") + kw["aname"] = "_OvfHostValueNotParsedFault" + if ns0.OvfHostValueNotParsed_Def not in ns0.OvfHostValueNotParsedFault_Dec.__bases__: + bases = list(ns0.OvfHostValueNotParsedFault_Dec.__bases__) + bases.insert(0, ns0.OvfHostValueNotParsed_Def) + ns0.OvfHostValueNotParsedFault_Dec.__bases__ = tuple(bases) + + ns0.OvfHostValueNotParsed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfHostValueNotParsedFault_Dec_Holder" + + class OvfImportFault_Dec(ElementDeclaration): + literal = "OvfImportFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfImportFault") + kw["aname"] = "_OvfImportFault" + if ns0.OvfImport_Def not in ns0.OvfImportFault_Dec.__bases__: + bases = list(ns0.OvfImportFault_Dec.__bases__) + bases.insert(0, ns0.OvfImport_Def) + ns0.OvfImportFault_Dec.__bases__ = tuple(bases) + + ns0.OvfImport_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfImportFault_Dec_Holder" + + class OvfInvalidPackageFault_Dec(ElementDeclaration): + literal = "OvfInvalidPackageFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfInvalidPackageFault") + kw["aname"] = "_OvfInvalidPackageFault" + if ns0.OvfInvalidPackage_Def not in ns0.OvfInvalidPackageFault_Dec.__bases__: + bases = list(ns0.OvfInvalidPackageFault_Dec.__bases__) + bases.insert(0, ns0.OvfInvalidPackage_Def) + ns0.OvfInvalidPackageFault_Dec.__bases__ = tuple(bases) + + ns0.OvfInvalidPackage_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidPackageFault_Dec_Holder" + + class OvfInvalidValueFault_Dec(ElementDeclaration): + literal = "OvfInvalidValueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfInvalidValueFault") + kw["aname"] = "_OvfInvalidValueFault" + if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueFault_Dec.__bases__: + bases = list(ns0.OvfInvalidValueFault_Dec.__bases__) + bases.insert(0, ns0.OvfInvalidValue_Def) + ns0.OvfInvalidValueFault_Dec.__bases__ = tuple(bases) + + ns0.OvfInvalidValue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueFault_Dec_Holder" + + class OvfInvalidValueConfigurationFault_Dec(ElementDeclaration): + literal = "OvfInvalidValueConfigurationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfInvalidValueConfigurationFault") + kw["aname"] = "_OvfInvalidValueConfigurationFault" + if ns0.OvfInvalidValueConfiguration_Def not in ns0.OvfInvalidValueConfigurationFault_Dec.__bases__: + bases = list(ns0.OvfInvalidValueConfigurationFault_Dec.__bases__) + bases.insert(0, ns0.OvfInvalidValueConfiguration_Def) + ns0.OvfInvalidValueConfigurationFault_Dec.__bases__ = tuple(bases) + + ns0.OvfInvalidValueConfiguration_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueConfigurationFault_Dec_Holder" + + class OvfInvalidValueEmptyFault_Dec(ElementDeclaration): + literal = "OvfInvalidValueEmptyFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfInvalidValueEmptyFault") + kw["aname"] = "_OvfInvalidValueEmptyFault" + if ns0.OvfInvalidValueEmpty_Def not in ns0.OvfInvalidValueEmptyFault_Dec.__bases__: + bases = list(ns0.OvfInvalidValueEmptyFault_Dec.__bases__) + bases.insert(0, ns0.OvfInvalidValueEmpty_Def) + ns0.OvfInvalidValueEmptyFault_Dec.__bases__ = tuple(bases) + + ns0.OvfInvalidValueEmpty_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueEmptyFault_Dec_Holder" + + class OvfInvalidValueFormatMalformedFault_Dec(ElementDeclaration): + literal = "OvfInvalidValueFormatMalformedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfInvalidValueFormatMalformedFault") + kw["aname"] = "_OvfInvalidValueFormatMalformedFault" + if ns0.OvfInvalidValueFormatMalformed_Def not in ns0.OvfInvalidValueFormatMalformedFault_Dec.__bases__: + bases = list(ns0.OvfInvalidValueFormatMalformedFault_Dec.__bases__) + bases.insert(0, ns0.OvfInvalidValueFormatMalformed_Def) + ns0.OvfInvalidValueFormatMalformedFault_Dec.__bases__ = tuple(bases) + + ns0.OvfInvalidValueFormatMalformed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueFormatMalformedFault_Dec_Holder" + + class OvfInvalidValueReferenceFault_Dec(ElementDeclaration): + literal = "OvfInvalidValueReferenceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfInvalidValueReferenceFault") + kw["aname"] = "_OvfInvalidValueReferenceFault" + if ns0.OvfInvalidValueReference_Def not in ns0.OvfInvalidValueReferenceFault_Dec.__bases__: + bases = list(ns0.OvfInvalidValueReferenceFault_Dec.__bases__) + bases.insert(0, ns0.OvfInvalidValueReference_Def) + ns0.OvfInvalidValueReferenceFault_Dec.__bases__ = tuple(bases) + + ns0.OvfInvalidValueReference_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueReferenceFault_Dec_Holder" + + class OvfInvalidVmNameFault_Dec(ElementDeclaration): + literal = "OvfInvalidVmNameFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfInvalidVmNameFault") + kw["aname"] = "_OvfInvalidVmNameFault" + if ns0.OvfInvalidVmName_Def not in ns0.OvfInvalidVmNameFault_Dec.__bases__: + bases = list(ns0.OvfInvalidVmNameFault_Dec.__bases__) + bases.insert(0, ns0.OvfInvalidVmName_Def) + ns0.OvfInvalidVmNameFault_Dec.__bases__ = tuple(bases) + + ns0.OvfInvalidVmName_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidVmNameFault_Dec_Holder" + + class OvfMappedOsIdFault_Dec(ElementDeclaration): + literal = "OvfMappedOsIdFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfMappedOsIdFault") + kw["aname"] = "_OvfMappedOsIdFault" + if ns0.OvfMappedOsId_Def not in ns0.OvfMappedOsIdFault_Dec.__bases__: + bases = list(ns0.OvfMappedOsIdFault_Dec.__bases__) + bases.insert(0, ns0.OvfMappedOsId_Def) + ns0.OvfMappedOsIdFault_Dec.__bases__ = tuple(bases) + + ns0.OvfMappedOsId_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfMappedOsIdFault_Dec_Holder" + + class OvfMissingAttributeFault_Dec(ElementDeclaration): + literal = "OvfMissingAttributeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfMissingAttributeFault") + kw["aname"] = "_OvfMissingAttributeFault" + if ns0.OvfMissingAttribute_Def not in ns0.OvfMissingAttributeFault_Dec.__bases__: + bases = list(ns0.OvfMissingAttributeFault_Dec.__bases__) + bases.insert(0, ns0.OvfMissingAttribute_Def) + ns0.OvfMissingAttributeFault_Dec.__bases__ = tuple(bases) + + ns0.OvfMissingAttribute_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingAttributeFault_Dec_Holder" + + class OvfMissingElementFault_Dec(ElementDeclaration): + literal = "OvfMissingElementFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfMissingElementFault") + kw["aname"] = "_OvfMissingElementFault" + if ns0.OvfMissingElement_Def not in ns0.OvfMissingElementFault_Dec.__bases__: + bases = list(ns0.OvfMissingElementFault_Dec.__bases__) + bases.insert(0, ns0.OvfMissingElement_Def) + ns0.OvfMissingElementFault_Dec.__bases__ = tuple(bases) + + ns0.OvfMissingElement_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingElementFault_Dec_Holder" + + class OvfMissingElementNormalBoundaryFault_Dec(ElementDeclaration): + literal = "OvfMissingElementNormalBoundaryFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfMissingElementNormalBoundaryFault") + kw["aname"] = "_OvfMissingElementNormalBoundaryFault" + if ns0.OvfMissingElementNormalBoundary_Def not in ns0.OvfMissingElementNormalBoundaryFault_Dec.__bases__: + bases = list(ns0.OvfMissingElementNormalBoundaryFault_Dec.__bases__) + bases.insert(0, ns0.OvfMissingElementNormalBoundary_Def) + ns0.OvfMissingElementNormalBoundaryFault_Dec.__bases__ = tuple(bases) + + ns0.OvfMissingElementNormalBoundary_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingElementNormalBoundaryFault_Dec_Holder" + + class OvfMissingHardwareFault_Dec(ElementDeclaration): + literal = "OvfMissingHardwareFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfMissingHardwareFault") + kw["aname"] = "_OvfMissingHardwareFault" + if ns0.OvfMissingHardware_Def not in ns0.OvfMissingHardwareFault_Dec.__bases__: + bases = list(ns0.OvfMissingHardwareFault_Dec.__bases__) + bases.insert(0, ns0.OvfMissingHardware_Def) + ns0.OvfMissingHardwareFault_Dec.__bases__ = tuple(bases) + + ns0.OvfMissingHardware_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingHardwareFault_Dec_Holder" + + class OvfNoHostNicFault_Dec(ElementDeclaration): + literal = "OvfNoHostNicFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfNoHostNicFault") + kw["aname"] = "_OvfNoHostNicFault" + if ns0.OvfNoHostNic_Def not in ns0.OvfNoHostNicFault_Dec.__bases__: + bases = list(ns0.OvfNoHostNicFault_Dec.__bases__) + bases.insert(0, ns0.OvfNoHostNic_Def) + ns0.OvfNoHostNicFault_Dec.__bases__ = tuple(bases) + + ns0.OvfNoHostNic_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfNoHostNicFault_Dec_Holder" + + class OvfNoSupportedHardwareFamilyFault_Dec(ElementDeclaration): + literal = "OvfNoSupportedHardwareFamilyFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfNoSupportedHardwareFamilyFault") + kw["aname"] = "_OvfNoSupportedHardwareFamilyFault" + if ns0.OvfNoSupportedHardwareFamily_Def not in ns0.OvfNoSupportedHardwareFamilyFault_Dec.__bases__: + bases = list(ns0.OvfNoSupportedHardwareFamilyFault_Dec.__bases__) + bases.insert(0, ns0.OvfNoSupportedHardwareFamily_Def) + ns0.OvfNoSupportedHardwareFamilyFault_Dec.__bases__ = tuple(bases) + + ns0.OvfNoSupportedHardwareFamily_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfNoSupportedHardwareFamilyFault_Dec_Holder" + + class OvfPropertyFault_Dec(ElementDeclaration): + literal = "OvfPropertyFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyFault") + kw["aname"] = "_OvfPropertyFault" + if ns0.OvfProperty_Def not in ns0.OvfPropertyFault_Dec.__bases__: + bases = list(ns0.OvfPropertyFault_Dec.__bases__) + bases.insert(0, ns0.OvfProperty_Def) + ns0.OvfPropertyFault_Dec.__bases__ = tuple(bases) + + ns0.OvfProperty_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyFault_Dec_Holder" + + class OvfPropertyExportFault_Dec(ElementDeclaration): + literal = "OvfPropertyExportFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyExportFault") + kw["aname"] = "_OvfPropertyExportFault" + if ns0.OvfPropertyExport_Def not in ns0.OvfPropertyExportFault_Dec.__bases__: + bases = list(ns0.OvfPropertyExportFault_Dec.__bases__) + bases.insert(0, ns0.OvfPropertyExport_Def) + ns0.OvfPropertyExportFault_Dec.__bases__ = tuple(bases) + + ns0.OvfPropertyExport_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyExportFault_Dec_Holder" + + class OvfPropertyNetworkFault_Dec(ElementDeclaration): + literal = "OvfPropertyNetworkFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyNetworkFault") + kw["aname"] = "_OvfPropertyNetworkFault" + if ns0.OvfPropertyNetwork_Def not in ns0.OvfPropertyNetworkFault_Dec.__bases__: + bases = list(ns0.OvfPropertyNetworkFault_Dec.__bases__) + bases.insert(0, ns0.OvfPropertyNetwork_Def) + ns0.OvfPropertyNetworkFault_Dec.__bases__ = tuple(bases) + + ns0.OvfPropertyNetwork_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyNetworkFault_Dec_Holder" + + class OvfPropertyQualifierFault_Dec(ElementDeclaration): + literal = "OvfPropertyQualifierFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyQualifierFault") + kw["aname"] = "_OvfPropertyQualifierFault" + if ns0.OvfPropertyQualifier_Def not in ns0.OvfPropertyQualifierFault_Dec.__bases__: + bases = list(ns0.OvfPropertyQualifierFault_Dec.__bases__) + bases.insert(0, ns0.OvfPropertyQualifier_Def) + ns0.OvfPropertyQualifierFault_Dec.__bases__ = tuple(bases) + + ns0.OvfPropertyQualifier_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyQualifierFault_Dec_Holder" + + class OvfPropertyQualifierDuplicateFault_Dec(ElementDeclaration): + literal = "OvfPropertyQualifierDuplicateFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyQualifierDuplicateFault") + kw["aname"] = "_OvfPropertyQualifierDuplicateFault" + if ns0.OvfPropertyQualifierDuplicate_Def not in ns0.OvfPropertyQualifierDuplicateFault_Dec.__bases__: + bases = list(ns0.OvfPropertyQualifierDuplicateFault_Dec.__bases__) + bases.insert(0, ns0.OvfPropertyQualifierDuplicate_Def) + ns0.OvfPropertyQualifierDuplicateFault_Dec.__bases__ = tuple(bases) + + ns0.OvfPropertyQualifierDuplicate_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyQualifierDuplicateFault_Dec_Holder" + + class OvfPropertyQualifierIgnoredFault_Dec(ElementDeclaration): + literal = "OvfPropertyQualifierIgnoredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyQualifierIgnoredFault") + kw["aname"] = "_OvfPropertyQualifierIgnoredFault" + if ns0.OvfPropertyQualifierIgnored_Def not in ns0.OvfPropertyQualifierIgnoredFault_Dec.__bases__: + bases = list(ns0.OvfPropertyQualifierIgnoredFault_Dec.__bases__) + bases.insert(0, ns0.OvfPropertyQualifierIgnored_Def) + ns0.OvfPropertyQualifierIgnoredFault_Dec.__bases__ = tuple(bases) + + ns0.OvfPropertyQualifierIgnored_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyQualifierIgnoredFault_Dec_Holder" + + class OvfPropertyTypeFault_Dec(ElementDeclaration): + literal = "OvfPropertyTypeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyTypeFault") + kw["aname"] = "_OvfPropertyTypeFault" + if ns0.OvfPropertyType_Def not in ns0.OvfPropertyTypeFault_Dec.__bases__: + bases = list(ns0.OvfPropertyTypeFault_Dec.__bases__) + bases.insert(0, ns0.OvfPropertyType_Def) + ns0.OvfPropertyTypeFault_Dec.__bases__ = tuple(bases) + + ns0.OvfPropertyType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyTypeFault_Dec_Holder" + + class OvfPropertyValueFault_Dec(ElementDeclaration): + literal = "OvfPropertyValueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfPropertyValueFault") + kw["aname"] = "_OvfPropertyValueFault" + if ns0.OvfPropertyValue_Def not in ns0.OvfPropertyValueFault_Dec.__bases__: + bases = list(ns0.OvfPropertyValueFault_Dec.__bases__) + bases.insert(0, ns0.OvfPropertyValue_Def) + ns0.OvfPropertyValueFault_Dec.__bases__ = tuple(bases) + + ns0.OvfPropertyValue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyValueFault_Dec_Holder" + + class OvfSystemFaultFault_Dec(ElementDeclaration): + literal = "OvfSystemFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfSystemFaultFault") + kw["aname"] = "_OvfSystemFaultFault" + if ns0.OvfSystemFault_Def not in ns0.OvfSystemFaultFault_Dec.__bases__: + bases = list(ns0.OvfSystemFaultFault_Dec.__bases__) + bases.insert(0, ns0.OvfSystemFault_Def) + ns0.OvfSystemFaultFault_Dec.__bases__ = tuple(bases) + + ns0.OvfSystemFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfSystemFaultFault_Dec_Holder" + + class OvfToXmlUnsupportedElementFault_Dec(ElementDeclaration): + literal = "OvfToXmlUnsupportedElementFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfToXmlUnsupportedElementFault") + kw["aname"] = "_OvfToXmlUnsupportedElementFault" + if ns0.OvfToXmlUnsupportedElement_Def not in ns0.OvfToXmlUnsupportedElementFault_Dec.__bases__: + bases = list(ns0.OvfToXmlUnsupportedElementFault_Dec.__bases__) + bases.insert(0, ns0.OvfToXmlUnsupportedElement_Def) + ns0.OvfToXmlUnsupportedElementFault_Dec.__bases__ = tuple(bases) + + ns0.OvfToXmlUnsupportedElement_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfToXmlUnsupportedElementFault_Dec_Holder" + + class OvfUnableToExportDiskFault_Dec(ElementDeclaration): + literal = "OvfUnableToExportDiskFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnableToExportDiskFault") + kw["aname"] = "_OvfUnableToExportDiskFault" + if ns0.OvfUnableToExportDisk_Def not in ns0.OvfUnableToExportDiskFault_Dec.__bases__: + bases = list(ns0.OvfUnableToExportDiskFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnableToExportDisk_Def) + ns0.OvfUnableToExportDiskFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnableToExportDisk_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnableToExportDiskFault_Dec_Holder" + + class OvfUnexpectedElementFault_Dec(ElementDeclaration): + literal = "OvfUnexpectedElementFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnexpectedElementFault") + kw["aname"] = "_OvfUnexpectedElementFault" + if ns0.OvfUnexpectedElement_Def not in ns0.OvfUnexpectedElementFault_Dec.__bases__: + bases = list(ns0.OvfUnexpectedElementFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnexpectedElement_Def) + ns0.OvfUnexpectedElementFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnexpectedElement_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnexpectedElementFault_Dec_Holder" + + class OvfUnknownDeviceFault_Dec(ElementDeclaration): + literal = "OvfUnknownDeviceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnknownDeviceFault") + kw["aname"] = "_OvfUnknownDeviceFault" + if ns0.OvfUnknownDevice_Def not in ns0.OvfUnknownDeviceFault_Dec.__bases__: + bases = list(ns0.OvfUnknownDeviceFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnknownDevice_Def) + ns0.OvfUnknownDeviceFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnknownDevice_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnknownDeviceFault_Dec_Holder" + + class OvfUnknownDeviceBackingFault_Dec(ElementDeclaration): + literal = "OvfUnknownDeviceBackingFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnknownDeviceBackingFault") + kw["aname"] = "_OvfUnknownDeviceBackingFault" + if ns0.OvfUnknownDeviceBacking_Def not in ns0.OvfUnknownDeviceBackingFault_Dec.__bases__: + bases = list(ns0.OvfUnknownDeviceBackingFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnknownDeviceBacking_Def) + ns0.OvfUnknownDeviceBackingFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnknownDeviceBacking_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnknownDeviceBackingFault_Dec_Holder" + + class OvfUnknownEntityFault_Dec(ElementDeclaration): + literal = "OvfUnknownEntityFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnknownEntityFault") + kw["aname"] = "_OvfUnknownEntityFault" + if ns0.OvfUnknownEntity_Def not in ns0.OvfUnknownEntityFault_Dec.__bases__: + bases = list(ns0.OvfUnknownEntityFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnknownEntity_Def) + ns0.OvfUnknownEntityFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnknownEntity_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnknownEntityFault_Dec_Holder" + + class OvfUnsupportedAttributeFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedAttributeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedAttributeFault") + kw["aname"] = "_OvfUnsupportedAttributeFault" + if ns0.OvfUnsupportedAttribute_Def not in ns0.OvfUnsupportedAttributeFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedAttributeFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedAttribute_Def) + ns0.OvfUnsupportedAttributeFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedAttribute_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedAttributeFault_Dec_Holder" + + class OvfUnsupportedAttributeValueFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedAttributeValueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedAttributeValueFault") + kw["aname"] = "_OvfUnsupportedAttributeValueFault" + if ns0.OvfUnsupportedAttributeValue_Def not in ns0.OvfUnsupportedAttributeValueFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedAttributeValueFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedAttributeValue_Def) + ns0.OvfUnsupportedAttributeValueFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedAttributeValue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedAttributeValueFault_Dec_Holder" + + class OvfUnsupportedDeviceBackingInfoFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedDeviceBackingInfoFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedDeviceBackingInfoFault") + kw["aname"] = "_OvfUnsupportedDeviceBackingInfoFault" + if ns0.OvfUnsupportedDeviceBackingInfo_Def not in ns0.OvfUnsupportedDeviceBackingInfoFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedDeviceBackingInfoFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedDeviceBackingInfo_Def) + ns0.OvfUnsupportedDeviceBackingInfoFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedDeviceBackingInfo_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedDeviceBackingInfoFault_Dec_Holder" + + class OvfUnsupportedDeviceBackingOptionFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedDeviceBackingOptionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedDeviceBackingOptionFault") + kw["aname"] = "_OvfUnsupportedDeviceBackingOptionFault" + if ns0.OvfUnsupportedDeviceBackingOption_Def not in ns0.OvfUnsupportedDeviceBackingOptionFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedDeviceBackingOptionFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedDeviceBackingOption_Def) + ns0.OvfUnsupportedDeviceBackingOptionFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedDeviceBackingOption_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedDeviceBackingOptionFault_Dec_Holder" + + class OvfUnsupportedDeviceExportFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedDeviceExportFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedDeviceExportFault") + kw["aname"] = "_OvfUnsupportedDeviceExportFault" + if ns0.OvfUnsupportedDeviceExport_Def not in ns0.OvfUnsupportedDeviceExportFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedDeviceExportFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedDeviceExport_Def) + ns0.OvfUnsupportedDeviceExportFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedDeviceExport_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedDeviceExportFault_Dec_Holder" + + class OvfUnsupportedElementFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedElementFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedElementFault") + kw["aname"] = "_OvfUnsupportedElementFault" + if ns0.OvfUnsupportedElement_Def not in ns0.OvfUnsupportedElementFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedElementFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedElement_Def) + ns0.OvfUnsupportedElementFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedElement_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedElementFault_Dec_Holder" + + class OvfUnsupportedElementValueFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedElementValueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedElementValueFault") + kw["aname"] = "_OvfUnsupportedElementValueFault" + if ns0.OvfUnsupportedElementValue_Def not in ns0.OvfUnsupportedElementValueFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedElementValueFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedElementValue_Def) + ns0.OvfUnsupportedElementValueFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedElementValue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedElementValueFault_Dec_Holder" + + class OvfUnsupportedPackageFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedPackageFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedPackageFault") + kw["aname"] = "_OvfUnsupportedPackageFault" + if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedPackageFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedPackageFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedPackage_Def) + ns0.OvfUnsupportedPackageFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedPackage_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedPackageFault_Dec_Holder" + + class OvfUnsupportedSectionFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedSectionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedSectionFault") + kw["aname"] = "_OvfUnsupportedSectionFault" + if ns0.OvfUnsupportedSection_Def not in ns0.OvfUnsupportedSectionFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedSectionFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedSection_Def) + ns0.OvfUnsupportedSectionFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedSection_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedSectionFault_Dec_Holder" + + class OvfUnsupportedSubTypeFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedSubTypeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedSubTypeFault") + kw["aname"] = "_OvfUnsupportedSubTypeFault" + if ns0.OvfUnsupportedSubType_Def not in ns0.OvfUnsupportedSubTypeFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedSubTypeFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedSubType_Def) + ns0.OvfUnsupportedSubTypeFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedSubType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedSubTypeFault_Dec_Holder" + + class OvfUnsupportedTypeFault_Dec(ElementDeclaration): + literal = "OvfUnsupportedTypeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfUnsupportedTypeFault") + kw["aname"] = "_OvfUnsupportedTypeFault" + if ns0.OvfUnsupportedType_Def not in ns0.OvfUnsupportedTypeFault_Dec.__bases__: + bases = list(ns0.OvfUnsupportedTypeFault_Dec.__bases__) + bases.insert(0, ns0.OvfUnsupportedType_Def) + ns0.OvfUnsupportedTypeFault_Dec.__bases__ = tuple(bases) + + ns0.OvfUnsupportedType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedTypeFault_Dec_Holder" + + class OvfWrongElementFault_Dec(ElementDeclaration): + literal = "OvfWrongElementFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfWrongElementFault") + kw["aname"] = "_OvfWrongElementFault" + if ns0.OvfWrongElement_Def not in ns0.OvfWrongElementFault_Dec.__bases__: + bases = list(ns0.OvfWrongElementFault_Dec.__bases__) + bases.insert(0, ns0.OvfWrongElement_Def) + ns0.OvfWrongElementFault_Dec.__bases__ = tuple(bases) + + ns0.OvfWrongElement_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfWrongElementFault_Dec_Holder" + + class OvfWrongNamespaceFault_Dec(ElementDeclaration): + literal = "OvfWrongNamespaceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfWrongNamespaceFault") + kw["aname"] = "_OvfWrongNamespaceFault" + if ns0.OvfWrongNamespace_Def not in ns0.OvfWrongNamespaceFault_Dec.__bases__: + bases = list(ns0.OvfWrongNamespaceFault_Dec.__bases__) + bases.insert(0, ns0.OvfWrongNamespace_Def) + ns0.OvfWrongNamespaceFault_Dec.__bases__ = tuple(bases) + + ns0.OvfWrongNamespace_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfWrongNamespaceFault_Dec_Holder" + + class OvfXmlFormatFault_Dec(ElementDeclaration): + literal = "OvfXmlFormatFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OvfXmlFormatFault") + kw["aname"] = "_OvfXmlFormatFault" + if ns0.OvfXmlFormat_Def not in ns0.OvfXmlFormatFault_Dec.__bases__: + bases = list(ns0.OvfXmlFormatFault_Dec.__bases__) + bases.insert(0, ns0.OvfXmlFormat_Def) + ns0.OvfXmlFormatFault_Dec.__bases__ = tuple(bases) + + ns0.OvfXmlFormat_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OvfXmlFormatFault_Dec_Holder" + + class PatchAlreadyInstalledFault_Dec(ElementDeclaration): + literal = "PatchAlreadyInstalledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchAlreadyInstalledFault") + kw["aname"] = "_PatchAlreadyInstalledFault" + if ns0.PatchAlreadyInstalled_Def not in ns0.PatchAlreadyInstalledFault_Dec.__bases__: + bases = list(ns0.PatchAlreadyInstalledFault_Dec.__bases__) + bases.insert(0, ns0.PatchAlreadyInstalled_Def) + ns0.PatchAlreadyInstalledFault_Dec.__bases__ = tuple(bases) + + ns0.PatchAlreadyInstalled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchAlreadyInstalledFault_Dec_Holder" + + class PatchBinariesNotFoundFault_Dec(ElementDeclaration): + literal = "PatchBinariesNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchBinariesNotFoundFault") + kw["aname"] = "_PatchBinariesNotFoundFault" + if ns0.PatchBinariesNotFound_Def not in ns0.PatchBinariesNotFoundFault_Dec.__bases__: + bases = list(ns0.PatchBinariesNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.PatchBinariesNotFound_Def) + ns0.PatchBinariesNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.PatchBinariesNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchBinariesNotFoundFault_Dec_Holder" + + class PatchInstallFailedFault_Dec(ElementDeclaration): + literal = "PatchInstallFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchInstallFailedFault") + kw["aname"] = "_PatchInstallFailedFault" + if ns0.PatchInstallFailed_Def not in ns0.PatchInstallFailedFault_Dec.__bases__: + bases = list(ns0.PatchInstallFailedFault_Dec.__bases__) + bases.insert(0, ns0.PatchInstallFailed_Def) + ns0.PatchInstallFailedFault_Dec.__bases__ = tuple(bases) + + ns0.PatchInstallFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchInstallFailedFault_Dec_Holder" + + class PatchIntegrityErrorFault_Dec(ElementDeclaration): + literal = "PatchIntegrityErrorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchIntegrityErrorFault") + kw["aname"] = "_PatchIntegrityErrorFault" + if ns0.PatchIntegrityError_Def not in ns0.PatchIntegrityErrorFault_Dec.__bases__: + bases = list(ns0.PatchIntegrityErrorFault_Dec.__bases__) + bases.insert(0, ns0.PatchIntegrityError_Def) + ns0.PatchIntegrityErrorFault_Dec.__bases__ = tuple(bases) + + ns0.PatchIntegrityError_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchIntegrityErrorFault_Dec_Holder" + + class PatchMetadataCorruptedFault_Dec(ElementDeclaration): + literal = "PatchMetadataCorruptedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchMetadataCorruptedFault") + kw["aname"] = "_PatchMetadataCorruptedFault" + if ns0.PatchMetadataCorrupted_Def not in ns0.PatchMetadataCorruptedFault_Dec.__bases__: + bases = list(ns0.PatchMetadataCorruptedFault_Dec.__bases__) + bases.insert(0, ns0.PatchMetadataCorrupted_Def) + ns0.PatchMetadataCorruptedFault_Dec.__bases__ = tuple(bases) + + ns0.PatchMetadataCorrupted_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchMetadataCorruptedFault_Dec_Holder" + + class PatchMetadataInvalidFault_Dec(ElementDeclaration): + literal = "PatchMetadataInvalidFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchMetadataInvalidFault") + kw["aname"] = "_PatchMetadataInvalidFault" + if ns0.PatchMetadataInvalid_Def not in ns0.PatchMetadataInvalidFault_Dec.__bases__: + bases = list(ns0.PatchMetadataInvalidFault_Dec.__bases__) + bases.insert(0, ns0.PatchMetadataInvalid_Def) + ns0.PatchMetadataInvalidFault_Dec.__bases__ = tuple(bases) + + ns0.PatchMetadataInvalid_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchMetadataInvalidFault_Dec_Holder" + + class PatchMetadataNotFoundFault_Dec(ElementDeclaration): + literal = "PatchMetadataNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchMetadataNotFoundFault") + kw["aname"] = "_PatchMetadataNotFoundFault" + if ns0.PatchMetadataNotFound_Def not in ns0.PatchMetadataNotFoundFault_Dec.__bases__: + bases = list(ns0.PatchMetadataNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.PatchMetadataNotFound_Def) + ns0.PatchMetadataNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.PatchMetadataNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchMetadataNotFoundFault_Dec_Holder" + + class PatchMissingDependenciesFault_Dec(ElementDeclaration): + literal = "PatchMissingDependenciesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchMissingDependenciesFault") + kw["aname"] = "_PatchMissingDependenciesFault" + if ns0.PatchMissingDependencies_Def not in ns0.PatchMissingDependenciesFault_Dec.__bases__: + bases = list(ns0.PatchMissingDependenciesFault_Dec.__bases__) + bases.insert(0, ns0.PatchMissingDependencies_Def) + ns0.PatchMissingDependenciesFault_Dec.__bases__ = tuple(bases) + + ns0.PatchMissingDependencies_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchMissingDependenciesFault_Dec_Holder" + + class PatchNotApplicableFault_Dec(ElementDeclaration): + literal = "PatchNotApplicableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchNotApplicableFault") + kw["aname"] = "_PatchNotApplicableFault" + if ns0.PatchNotApplicable_Def not in ns0.PatchNotApplicableFault_Dec.__bases__: + bases = list(ns0.PatchNotApplicableFault_Dec.__bases__) + bases.insert(0, ns0.PatchNotApplicable_Def) + ns0.PatchNotApplicableFault_Dec.__bases__ = tuple(bases) + + ns0.PatchNotApplicable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchNotApplicableFault_Dec_Holder" + + class PatchSupersededFault_Dec(ElementDeclaration): + literal = "PatchSupersededFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PatchSupersededFault") + kw["aname"] = "_PatchSupersededFault" + if ns0.PatchSuperseded_Def not in ns0.PatchSupersededFault_Dec.__bases__: + bases = list(ns0.PatchSupersededFault_Dec.__bases__) + bases.insert(0, ns0.PatchSuperseded_Def) + ns0.PatchSupersededFault_Dec.__bases__ = tuple(bases) + + ns0.PatchSuperseded_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PatchSupersededFault_Dec_Holder" + + class PhysCompatRDMNotSupportedFault_Dec(ElementDeclaration): + literal = "PhysCompatRDMNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PhysCompatRDMNotSupportedFault") + kw["aname"] = "_PhysCompatRDMNotSupportedFault" + if ns0.PhysCompatRDMNotSupported_Def not in ns0.PhysCompatRDMNotSupportedFault_Dec.__bases__: + bases = list(ns0.PhysCompatRDMNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.PhysCompatRDMNotSupported_Def) + ns0.PhysCompatRDMNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.PhysCompatRDMNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PhysCompatRDMNotSupportedFault_Dec_Holder" + + class PlatformConfigFaultFault_Dec(ElementDeclaration): + literal = "PlatformConfigFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PlatformConfigFaultFault") + kw["aname"] = "_PlatformConfigFaultFault" + if ns0.PlatformConfigFault_Def not in ns0.PlatformConfigFaultFault_Dec.__bases__: + bases = list(ns0.PlatformConfigFaultFault_Dec.__bases__) + bases.insert(0, ns0.PlatformConfigFault_Def) + ns0.PlatformConfigFaultFault_Dec.__bases__ = tuple(bases) + + ns0.PlatformConfigFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PlatformConfigFaultFault_Dec_Holder" + + class PowerOnFtSecondaryFailedFault_Dec(ElementDeclaration): + literal = "PowerOnFtSecondaryFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnFtSecondaryFailedFault") + kw["aname"] = "_PowerOnFtSecondaryFailedFault" + if ns0.PowerOnFtSecondaryFailed_Def not in ns0.PowerOnFtSecondaryFailedFault_Dec.__bases__: + bases = list(ns0.PowerOnFtSecondaryFailedFault_Dec.__bases__) + bases.insert(0, ns0.PowerOnFtSecondaryFailed_Def) + ns0.PowerOnFtSecondaryFailedFault_Dec.__bases__ = tuple(bases) + + ns0.PowerOnFtSecondaryFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnFtSecondaryFailedFault_Dec_Holder" + + class PowerOnFtSecondaryTimedoutFault_Dec(ElementDeclaration): + literal = "PowerOnFtSecondaryTimedoutFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","PowerOnFtSecondaryTimedoutFault") + kw["aname"] = "_PowerOnFtSecondaryTimedoutFault" + if ns0.PowerOnFtSecondaryTimedout_Def not in ns0.PowerOnFtSecondaryTimedoutFault_Dec.__bases__: + bases = list(ns0.PowerOnFtSecondaryTimedoutFault_Dec.__bases__) + bases.insert(0, ns0.PowerOnFtSecondaryTimedout_Def) + ns0.PowerOnFtSecondaryTimedoutFault_Dec.__bases__ = tuple(bases) + + ns0.PowerOnFtSecondaryTimedout_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "PowerOnFtSecondaryTimedoutFault_Dec_Holder" + + class ProfileUpdateFailedFault_Dec(ElementDeclaration): + literal = "ProfileUpdateFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileUpdateFailedFault") + kw["aname"] = "_ProfileUpdateFailedFault" + if ns0.ProfileUpdateFailed_Def not in ns0.ProfileUpdateFailedFault_Dec.__bases__: + bases = list(ns0.ProfileUpdateFailedFault_Dec.__bases__) + bases.insert(0, ns0.ProfileUpdateFailed_Def) + ns0.ProfileUpdateFailedFault_Dec.__bases__ = tuple(bases) + + ns0.ProfileUpdateFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileUpdateFailedFault_Dec_Holder" + + class RDMConversionNotSupportedFault_Dec(ElementDeclaration): + literal = "RDMConversionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RDMConversionNotSupportedFault") + kw["aname"] = "_RDMConversionNotSupportedFault" + if ns0.RDMConversionNotSupported_Def not in ns0.RDMConversionNotSupportedFault_Dec.__bases__: + bases = list(ns0.RDMConversionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.RDMConversionNotSupported_Def) + ns0.RDMConversionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.RDMConversionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RDMConversionNotSupportedFault_Dec_Holder" + + class RDMNotPreservedFault_Dec(ElementDeclaration): + literal = "RDMNotPreservedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RDMNotPreservedFault") + kw["aname"] = "_RDMNotPreservedFault" + if ns0.RDMNotPreserved_Def not in ns0.RDMNotPreservedFault_Dec.__bases__: + bases = list(ns0.RDMNotPreservedFault_Dec.__bases__) + bases.insert(0, ns0.RDMNotPreserved_Def) + ns0.RDMNotPreservedFault_Dec.__bases__ = tuple(bases) + + ns0.RDMNotPreserved_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RDMNotPreservedFault_Dec_Holder" + + class RDMNotSupportedFault_Dec(ElementDeclaration): + literal = "RDMNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RDMNotSupportedFault") + kw["aname"] = "_RDMNotSupportedFault" + if ns0.RDMNotSupported_Def not in ns0.RDMNotSupportedFault_Dec.__bases__: + bases = list(ns0.RDMNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.RDMNotSupported_Def) + ns0.RDMNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.RDMNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RDMNotSupportedFault_Dec_Holder" + + class RDMNotSupportedOnDatastoreFault_Dec(ElementDeclaration): + literal = "RDMNotSupportedOnDatastoreFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RDMNotSupportedOnDatastoreFault") + kw["aname"] = "_RDMNotSupportedOnDatastoreFault" + if ns0.RDMNotSupportedOnDatastore_Def not in ns0.RDMNotSupportedOnDatastoreFault_Dec.__bases__: + bases = list(ns0.RDMNotSupportedOnDatastoreFault_Dec.__bases__) + bases.insert(0, ns0.RDMNotSupportedOnDatastore_Def) + ns0.RDMNotSupportedOnDatastoreFault_Dec.__bases__ = tuple(bases) + + ns0.RDMNotSupportedOnDatastore_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RDMNotSupportedOnDatastoreFault_Dec_Holder" + + class RDMPointsToInaccessibleDiskFault_Dec(ElementDeclaration): + literal = "RDMPointsToInaccessibleDiskFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RDMPointsToInaccessibleDiskFault") + kw["aname"] = "_RDMPointsToInaccessibleDiskFault" + if ns0.RDMPointsToInaccessibleDisk_Def not in ns0.RDMPointsToInaccessibleDiskFault_Dec.__bases__: + bases = list(ns0.RDMPointsToInaccessibleDiskFault_Dec.__bases__) + bases.insert(0, ns0.RDMPointsToInaccessibleDisk_Def) + ns0.RDMPointsToInaccessibleDiskFault_Dec.__bases__ = tuple(bases) + + ns0.RDMPointsToInaccessibleDisk_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RDMPointsToInaccessibleDiskFault_Dec_Holder" + + class RawDiskNotSupportedFault_Dec(ElementDeclaration): + literal = "RawDiskNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RawDiskNotSupportedFault") + kw["aname"] = "_RawDiskNotSupportedFault" + if ns0.RawDiskNotSupported_Def not in ns0.RawDiskNotSupportedFault_Dec.__bases__: + bases = list(ns0.RawDiskNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.RawDiskNotSupported_Def) + ns0.RawDiskNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.RawDiskNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RawDiskNotSupportedFault_Dec_Holder" + + class ReadOnlyDisksWithLegacyDestinationFault_Dec(ElementDeclaration): + literal = "ReadOnlyDisksWithLegacyDestinationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReadOnlyDisksWithLegacyDestinationFault") + kw["aname"] = "_ReadOnlyDisksWithLegacyDestinationFault" + if ns0.ReadOnlyDisksWithLegacyDestination_Def not in ns0.ReadOnlyDisksWithLegacyDestinationFault_Dec.__bases__: + bases = list(ns0.ReadOnlyDisksWithLegacyDestinationFault_Dec.__bases__) + bases.insert(0, ns0.ReadOnlyDisksWithLegacyDestination_Def) + ns0.ReadOnlyDisksWithLegacyDestinationFault_Dec.__bases__ = tuple(bases) + + ns0.ReadOnlyDisksWithLegacyDestination_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReadOnlyDisksWithLegacyDestinationFault_Dec_Holder" + + class RebootRequiredFault_Dec(ElementDeclaration): + literal = "RebootRequiredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RebootRequiredFault") + kw["aname"] = "_RebootRequiredFault" + if ns0.RebootRequired_Def not in ns0.RebootRequiredFault_Dec.__bases__: + bases = list(ns0.RebootRequiredFault_Dec.__bases__) + bases.insert(0, ns0.RebootRequired_Def) + ns0.RebootRequiredFault_Dec.__bases__ = tuple(bases) + + ns0.RebootRequired_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RebootRequiredFault_Dec_Holder" + + class RecordReplayDisabledFault_Dec(ElementDeclaration): + literal = "RecordReplayDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RecordReplayDisabledFault") + kw["aname"] = "_RecordReplayDisabledFault" + if ns0.RecordReplayDisabled_Def not in ns0.RecordReplayDisabledFault_Dec.__bases__: + bases = list(ns0.RecordReplayDisabledFault_Dec.__bases__) + bases.insert(0, ns0.RecordReplayDisabled_Def) + ns0.RecordReplayDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.RecordReplayDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RecordReplayDisabledFault_Dec_Holder" + + class RemoteDeviceNotSupportedFault_Dec(ElementDeclaration): + literal = "RemoteDeviceNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoteDeviceNotSupportedFault") + kw["aname"] = "_RemoteDeviceNotSupportedFault" + if ns0.RemoteDeviceNotSupported_Def not in ns0.RemoteDeviceNotSupportedFault_Dec.__bases__: + bases = list(ns0.RemoteDeviceNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.RemoteDeviceNotSupported_Def) + ns0.RemoteDeviceNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.RemoteDeviceNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoteDeviceNotSupportedFault_Dec_Holder" + + class RemoveFailedFault_Dec(ElementDeclaration): + literal = "RemoveFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveFailedFault") + kw["aname"] = "_RemoveFailedFault" + if ns0.RemoveFailed_Def not in ns0.RemoveFailedFault_Dec.__bases__: + bases = list(ns0.RemoveFailedFault_Dec.__bases__) + bases.insert(0, ns0.RemoveFailed_Def) + ns0.RemoveFailedFault_Dec.__bases__ = tuple(bases) + + ns0.RemoveFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveFailedFault_Dec_Holder" + + class ResourceInUseFault_Dec(ElementDeclaration): + literal = "ResourceInUseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResourceInUseFault") + kw["aname"] = "_ResourceInUseFault" + if ns0.ResourceInUse_Def not in ns0.ResourceInUseFault_Dec.__bases__: + bases = list(ns0.ResourceInUseFault_Dec.__bases__) + bases.insert(0, ns0.ResourceInUse_Def) + ns0.ResourceInUseFault_Dec.__bases__ = tuple(bases) + + ns0.ResourceInUse_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResourceInUseFault_Dec_Holder" + + class ResourceNotAvailableFault_Dec(ElementDeclaration): + literal = "ResourceNotAvailableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResourceNotAvailableFault") + kw["aname"] = "_ResourceNotAvailableFault" + if ns0.ResourceNotAvailable_Def not in ns0.ResourceNotAvailableFault_Dec.__bases__: + bases = list(ns0.ResourceNotAvailableFault_Dec.__bases__) + bases.insert(0, ns0.ResourceNotAvailable_Def) + ns0.ResourceNotAvailableFault_Dec.__bases__ = tuple(bases) + + ns0.ResourceNotAvailable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResourceNotAvailableFault_Dec_Holder" + + class RestrictedVersionFault_Dec(ElementDeclaration): + literal = "RestrictedVersionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RestrictedVersionFault") + kw["aname"] = "_RestrictedVersionFault" + if ns0.RestrictedVersion_Def not in ns0.RestrictedVersionFault_Dec.__bases__: + bases = list(ns0.RestrictedVersionFault_Dec.__bases__) + bases.insert(0, ns0.RestrictedVersion_Def) + ns0.RestrictedVersionFault_Dec.__bases__ = tuple(bases) + + ns0.RestrictedVersion_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RestrictedVersionFault_Dec_Holder" + + class RuleViolationFault_Dec(ElementDeclaration): + literal = "RuleViolationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RuleViolationFault") + kw["aname"] = "_RuleViolationFault" + if ns0.RuleViolation_Def not in ns0.RuleViolationFault_Dec.__bases__: + bases = list(ns0.RuleViolationFault_Dec.__bases__) + bases.insert(0, ns0.RuleViolation_Def) + ns0.RuleViolationFault_Dec.__bases__ = tuple(bases) + + ns0.RuleViolation_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RuleViolationFault_Dec_Holder" + + class SSLDisabledFaultFault_Dec(ElementDeclaration): + literal = "SSLDisabledFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SSLDisabledFaultFault") + kw["aname"] = "_SSLDisabledFaultFault" + if ns0.SSLDisabledFault_Def not in ns0.SSLDisabledFaultFault_Dec.__bases__: + bases = list(ns0.SSLDisabledFaultFault_Dec.__bases__) + bases.insert(0, ns0.SSLDisabledFault_Def) + ns0.SSLDisabledFaultFault_Dec.__bases__ = tuple(bases) + + ns0.SSLDisabledFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SSLDisabledFaultFault_Dec_Holder" + + class SSLVerifyFaultFault_Dec(ElementDeclaration): + literal = "SSLVerifyFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SSLVerifyFaultFault") + kw["aname"] = "_SSLVerifyFaultFault" + if ns0.SSLVerifyFault_Def not in ns0.SSLVerifyFaultFault_Dec.__bases__: + bases = list(ns0.SSLVerifyFaultFault_Dec.__bases__) + bases.insert(0, ns0.SSLVerifyFault_Def) + ns0.SSLVerifyFaultFault_Dec.__bases__ = tuple(bases) + + ns0.SSLVerifyFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SSLVerifyFaultFault_Dec_Holder" + + class SSPIChallengeFault_Dec(ElementDeclaration): + literal = "SSPIChallengeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SSPIChallengeFault") + kw["aname"] = "_SSPIChallengeFault" + if ns0.SSPIChallenge_Def not in ns0.SSPIChallengeFault_Dec.__bases__: + bases = list(ns0.SSPIChallengeFault_Dec.__bases__) + bases.insert(0, ns0.SSPIChallenge_Def) + ns0.SSPIChallengeFault_Dec.__bases__ = tuple(bases) + + ns0.SSPIChallenge_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SSPIChallengeFault_Dec_Holder" + + class SecondaryVmAlreadyDisabledFault_Dec(ElementDeclaration): + literal = "SecondaryVmAlreadyDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SecondaryVmAlreadyDisabledFault") + kw["aname"] = "_SecondaryVmAlreadyDisabledFault" + if ns0.SecondaryVmAlreadyDisabled_Def not in ns0.SecondaryVmAlreadyDisabledFault_Dec.__bases__: + bases = list(ns0.SecondaryVmAlreadyDisabledFault_Dec.__bases__) + bases.insert(0, ns0.SecondaryVmAlreadyDisabled_Def) + ns0.SecondaryVmAlreadyDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.SecondaryVmAlreadyDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmAlreadyDisabledFault_Dec_Holder" + + class SecondaryVmAlreadyEnabledFault_Dec(ElementDeclaration): + literal = "SecondaryVmAlreadyEnabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SecondaryVmAlreadyEnabledFault") + kw["aname"] = "_SecondaryVmAlreadyEnabledFault" + if ns0.SecondaryVmAlreadyEnabled_Def not in ns0.SecondaryVmAlreadyEnabledFault_Dec.__bases__: + bases = list(ns0.SecondaryVmAlreadyEnabledFault_Dec.__bases__) + bases.insert(0, ns0.SecondaryVmAlreadyEnabled_Def) + ns0.SecondaryVmAlreadyEnabledFault_Dec.__bases__ = tuple(bases) + + ns0.SecondaryVmAlreadyEnabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmAlreadyEnabledFault_Dec_Holder" + + class SecondaryVmAlreadyRegisteredFault_Dec(ElementDeclaration): + literal = "SecondaryVmAlreadyRegisteredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SecondaryVmAlreadyRegisteredFault") + kw["aname"] = "_SecondaryVmAlreadyRegisteredFault" + if ns0.SecondaryVmAlreadyRegistered_Def not in ns0.SecondaryVmAlreadyRegisteredFault_Dec.__bases__: + bases = list(ns0.SecondaryVmAlreadyRegisteredFault_Dec.__bases__) + bases.insert(0, ns0.SecondaryVmAlreadyRegistered_Def) + ns0.SecondaryVmAlreadyRegisteredFault_Dec.__bases__ = tuple(bases) + + ns0.SecondaryVmAlreadyRegistered_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmAlreadyRegisteredFault_Dec_Holder" + + class SecondaryVmNotRegisteredFault_Dec(ElementDeclaration): + literal = "SecondaryVmNotRegisteredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SecondaryVmNotRegisteredFault") + kw["aname"] = "_SecondaryVmNotRegisteredFault" + if ns0.SecondaryVmNotRegistered_Def not in ns0.SecondaryVmNotRegisteredFault_Dec.__bases__: + bases = list(ns0.SecondaryVmNotRegisteredFault_Dec.__bases__) + bases.insert(0, ns0.SecondaryVmNotRegistered_Def) + ns0.SecondaryVmNotRegisteredFault_Dec.__bases__ = tuple(bases) + + ns0.SecondaryVmNotRegistered_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmNotRegisteredFault_Dec_Holder" + + class SharedBusControllerNotSupportedFault_Dec(ElementDeclaration): + literal = "SharedBusControllerNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SharedBusControllerNotSupportedFault") + kw["aname"] = "_SharedBusControllerNotSupportedFault" + if ns0.SharedBusControllerNotSupported_Def not in ns0.SharedBusControllerNotSupportedFault_Dec.__bases__: + bases = list(ns0.SharedBusControllerNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SharedBusControllerNotSupported_Def) + ns0.SharedBusControllerNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SharedBusControllerNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SharedBusControllerNotSupportedFault_Dec_Holder" + + class SnapshotCloneNotSupportedFault_Dec(ElementDeclaration): + literal = "SnapshotCloneNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotCloneNotSupportedFault") + kw["aname"] = "_SnapshotCloneNotSupportedFault" + if ns0.SnapshotCloneNotSupported_Def not in ns0.SnapshotCloneNotSupportedFault_Dec.__bases__: + bases = list(ns0.SnapshotCloneNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotCloneNotSupported_Def) + ns0.SnapshotCloneNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotCloneNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotCloneNotSupportedFault_Dec_Holder" + + class SnapshotCopyNotSupportedFault_Dec(ElementDeclaration): + literal = "SnapshotCopyNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotCopyNotSupportedFault") + kw["aname"] = "_SnapshotCopyNotSupportedFault" + if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotCopyNotSupportedFault_Dec.__bases__: + bases = list(ns0.SnapshotCopyNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotCopyNotSupported_Def) + ns0.SnapshotCopyNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotCopyNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotCopyNotSupportedFault_Dec_Holder" + + class SnapshotDisabledFault_Dec(ElementDeclaration): + literal = "SnapshotDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotDisabledFault") + kw["aname"] = "_SnapshotDisabledFault" + if ns0.SnapshotDisabled_Def not in ns0.SnapshotDisabledFault_Dec.__bases__: + bases = list(ns0.SnapshotDisabledFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotDisabled_Def) + ns0.SnapshotDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotDisabledFault_Dec_Holder" + + class SnapshotFaultFault_Dec(ElementDeclaration): + literal = "SnapshotFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotFaultFault") + kw["aname"] = "_SnapshotFaultFault" + if ns0.SnapshotFault_Def not in ns0.SnapshotFaultFault_Dec.__bases__: + bases = list(ns0.SnapshotFaultFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotFault_Def) + ns0.SnapshotFaultFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotFaultFault_Dec_Holder" + + class SnapshotIncompatibleDeviceInVmFault_Dec(ElementDeclaration): + literal = "SnapshotIncompatibleDeviceInVmFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotIncompatibleDeviceInVmFault") + kw["aname"] = "_SnapshotIncompatibleDeviceInVmFault" + if ns0.SnapshotIncompatibleDeviceInVm_Def not in ns0.SnapshotIncompatibleDeviceInVmFault_Dec.__bases__: + bases = list(ns0.SnapshotIncompatibleDeviceInVmFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotIncompatibleDeviceInVm_Def) + ns0.SnapshotIncompatibleDeviceInVmFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotIncompatibleDeviceInVm_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotIncompatibleDeviceInVmFault_Dec_Holder" + + class SnapshotLockedFault_Dec(ElementDeclaration): + literal = "SnapshotLockedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotLockedFault") + kw["aname"] = "_SnapshotLockedFault" + if ns0.SnapshotLocked_Def not in ns0.SnapshotLockedFault_Dec.__bases__: + bases = list(ns0.SnapshotLockedFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotLocked_Def) + ns0.SnapshotLockedFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotLocked_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotLockedFault_Dec_Holder" + + class SnapshotMoveFromNonHomeNotSupportedFault_Dec(ElementDeclaration): + literal = "SnapshotMoveFromNonHomeNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotMoveFromNonHomeNotSupportedFault") + kw["aname"] = "_SnapshotMoveFromNonHomeNotSupportedFault" + if ns0.SnapshotMoveFromNonHomeNotSupported_Def not in ns0.SnapshotMoveFromNonHomeNotSupportedFault_Dec.__bases__: + bases = list(ns0.SnapshotMoveFromNonHomeNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotMoveFromNonHomeNotSupported_Def) + ns0.SnapshotMoveFromNonHomeNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotMoveFromNonHomeNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotMoveFromNonHomeNotSupportedFault_Dec_Holder" + + class SnapshotMoveNotSupportedFault_Dec(ElementDeclaration): + literal = "SnapshotMoveNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotMoveNotSupportedFault") + kw["aname"] = "_SnapshotMoveNotSupportedFault" + if ns0.SnapshotMoveNotSupported_Def not in ns0.SnapshotMoveNotSupportedFault_Dec.__bases__: + bases = list(ns0.SnapshotMoveNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotMoveNotSupported_Def) + ns0.SnapshotMoveNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotMoveNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotMoveNotSupportedFault_Dec_Holder" + + class SnapshotMoveToNonHomeNotSupportedFault_Dec(ElementDeclaration): + literal = "SnapshotMoveToNonHomeNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotMoveToNonHomeNotSupportedFault") + kw["aname"] = "_SnapshotMoveToNonHomeNotSupportedFault" + if ns0.SnapshotMoveToNonHomeNotSupported_Def not in ns0.SnapshotMoveToNonHomeNotSupportedFault_Dec.__bases__: + bases = list(ns0.SnapshotMoveToNonHomeNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotMoveToNonHomeNotSupported_Def) + ns0.SnapshotMoveToNonHomeNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotMoveToNonHomeNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotMoveToNonHomeNotSupportedFault_Dec_Holder" + + class SnapshotNoChangeFault_Dec(ElementDeclaration): + literal = "SnapshotNoChangeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotNoChangeFault") + kw["aname"] = "_SnapshotNoChangeFault" + if ns0.SnapshotNoChange_Def not in ns0.SnapshotNoChangeFault_Dec.__bases__: + bases = list(ns0.SnapshotNoChangeFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotNoChange_Def) + ns0.SnapshotNoChangeFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotNoChange_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotNoChangeFault_Dec_Holder" + + class SnapshotRevertIssueFault_Dec(ElementDeclaration): + literal = "SnapshotRevertIssueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SnapshotRevertIssueFault") + kw["aname"] = "_SnapshotRevertIssueFault" + if ns0.SnapshotRevertIssue_Def not in ns0.SnapshotRevertIssueFault_Dec.__bases__: + bases = list(ns0.SnapshotRevertIssueFault_Dec.__bases__) + bases.insert(0, ns0.SnapshotRevertIssue_Def) + ns0.SnapshotRevertIssueFault_Dec.__bases__ = tuple(bases) + + ns0.SnapshotRevertIssue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SnapshotRevertIssueFault_Dec_Holder" + + class StorageVMotionNotSupportedFault_Dec(ElementDeclaration): + literal = "StorageVMotionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StorageVMotionNotSupportedFault") + kw["aname"] = "_StorageVMotionNotSupportedFault" + if ns0.StorageVMotionNotSupported_Def not in ns0.StorageVMotionNotSupportedFault_Dec.__bases__: + bases = list(ns0.StorageVMotionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.StorageVMotionNotSupported_Def) + ns0.StorageVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.StorageVMotionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StorageVMotionNotSupportedFault_Dec_Holder" + + class SuspendedRelocateNotSupportedFault_Dec(ElementDeclaration): + literal = "SuspendedRelocateNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SuspendedRelocateNotSupportedFault") + kw["aname"] = "_SuspendedRelocateNotSupportedFault" + if ns0.SuspendedRelocateNotSupported_Def not in ns0.SuspendedRelocateNotSupportedFault_Dec.__bases__: + bases = list(ns0.SuspendedRelocateNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SuspendedRelocateNotSupported_Def) + ns0.SuspendedRelocateNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SuspendedRelocateNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SuspendedRelocateNotSupportedFault_Dec_Holder" + + class SwapDatastoreNotWritableOnHostFault_Dec(ElementDeclaration): + literal = "SwapDatastoreNotWritableOnHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SwapDatastoreNotWritableOnHostFault") + kw["aname"] = "_SwapDatastoreNotWritableOnHostFault" + if ns0.SwapDatastoreNotWritableOnHost_Def not in ns0.SwapDatastoreNotWritableOnHostFault_Dec.__bases__: + bases = list(ns0.SwapDatastoreNotWritableOnHostFault_Dec.__bases__) + bases.insert(0, ns0.SwapDatastoreNotWritableOnHost_Def) + ns0.SwapDatastoreNotWritableOnHostFault_Dec.__bases__ = tuple(bases) + + ns0.SwapDatastoreNotWritableOnHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SwapDatastoreNotWritableOnHostFault_Dec_Holder" + + class SwapDatastoreUnsetFault_Dec(ElementDeclaration): + literal = "SwapDatastoreUnsetFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SwapDatastoreUnsetFault") + kw["aname"] = "_SwapDatastoreUnsetFault" + if ns0.SwapDatastoreUnset_Def not in ns0.SwapDatastoreUnsetFault_Dec.__bases__: + bases = list(ns0.SwapDatastoreUnsetFault_Dec.__bases__) + bases.insert(0, ns0.SwapDatastoreUnset_Def) + ns0.SwapDatastoreUnsetFault_Dec.__bases__ = tuple(bases) + + ns0.SwapDatastoreUnset_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SwapDatastoreUnsetFault_Dec_Holder" + + class SwapPlacementOverrideNotSupportedFault_Dec(ElementDeclaration): + literal = "SwapPlacementOverrideNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SwapPlacementOverrideNotSupportedFault") + kw["aname"] = "_SwapPlacementOverrideNotSupportedFault" + if ns0.SwapPlacementOverrideNotSupported_Def not in ns0.SwapPlacementOverrideNotSupportedFault_Dec.__bases__: + bases = list(ns0.SwapPlacementOverrideNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.SwapPlacementOverrideNotSupported_Def) + ns0.SwapPlacementOverrideNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.SwapPlacementOverrideNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SwapPlacementOverrideNotSupportedFault_Dec_Holder" + + class SwitchNotInUpgradeModeFault_Dec(ElementDeclaration): + literal = "SwitchNotInUpgradeModeFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SwitchNotInUpgradeModeFault") + kw["aname"] = "_SwitchNotInUpgradeModeFault" + if ns0.SwitchNotInUpgradeMode_Def not in ns0.SwitchNotInUpgradeModeFault_Dec.__bases__: + bases = list(ns0.SwitchNotInUpgradeModeFault_Dec.__bases__) + bases.insert(0, ns0.SwitchNotInUpgradeMode_Def) + ns0.SwitchNotInUpgradeModeFault_Dec.__bases__ = tuple(bases) + + ns0.SwitchNotInUpgradeMode_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SwitchNotInUpgradeModeFault_Dec_Holder" + + class TaskInProgressFault_Dec(ElementDeclaration): + literal = "TaskInProgressFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TaskInProgressFault") + kw["aname"] = "_TaskInProgressFault" + if ns0.TaskInProgress_Def not in ns0.TaskInProgressFault_Dec.__bases__: + bases = list(ns0.TaskInProgressFault_Dec.__bases__) + bases.insert(0, ns0.TaskInProgress_Def) + ns0.TaskInProgressFault_Dec.__bases__ = tuple(bases) + + ns0.TaskInProgress_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TaskInProgressFault_Dec_Holder" + + class TimedoutFault_Dec(ElementDeclaration): + literal = "TimedoutFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TimedoutFault") + kw["aname"] = "_TimedoutFault" + if ns0.Timedout_Def not in ns0.TimedoutFault_Dec.__bases__: + bases = list(ns0.TimedoutFault_Dec.__bases__) + bases.insert(0, ns0.Timedout_Def) + ns0.TimedoutFault_Dec.__bases__ = tuple(bases) + + ns0.Timedout_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TimedoutFault_Dec_Holder" + + class TooManyConsecutiveOverridesFault_Dec(ElementDeclaration): + literal = "TooManyConsecutiveOverridesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TooManyConsecutiveOverridesFault") + kw["aname"] = "_TooManyConsecutiveOverridesFault" + if ns0.TooManyConsecutiveOverrides_Def not in ns0.TooManyConsecutiveOverridesFault_Dec.__bases__: + bases = list(ns0.TooManyConsecutiveOverridesFault_Dec.__bases__) + bases.insert(0, ns0.TooManyConsecutiveOverrides_Def) + ns0.TooManyConsecutiveOverridesFault_Dec.__bases__ = tuple(bases) + + ns0.TooManyConsecutiveOverrides_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TooManyConsecutiveOverridesFault_Dec_Holder" + + class TooManyDevicesFault_Dec(ElementDeclaration): + literal = "TooManyDevicesFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TooManyDevicesFault") + kw["aname"] = "_TooManyDevicesFault" + if ns0.TooManyDevices_Def not in ns0.TooManyDevicesFault_Dec.__bases__: + bases = list(ns0.TooManyDevicesFault_Dec.__bases__) + bases.insert(0, ns0.TooManyDevices_Def) + ns0.TooManyDevicesFault_Dec.__bases__ = tuple(bases) + + ns0.TooManyDevices_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TooManyDevicesFault_Dec_Holder" + + class TooManyDisksOnLegacyHostFault_Dec(ElementDeclaration): + literal = "TooManyDisksOnLegacyHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TooManyDisksOnLegacyHostFault") + kw["aname"] = "_TooManyDisksOnLegacyHostFault" + if ns0.TooManyDisksOnLegacyHost_Def not in ns0.TooManyDisksOnLegacyHostFault_Dec.__bases__: + bases = list(ns0.TooManyDisksOnLegacyHostFault_Dec.__bases__) + bases.insert(0, ns0.TooManyDisksOnLegacyHost_Def) + ns0.TooManyDisksOnLegacyHostFault_Dec.__bases__ = tuple(bases) + + ns0.TooManyDisksOnLegacyHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TooManyDisksOnLegacyHostFault_Dec_Holder" + + class TooManyHostsFault_Dec(ElementDeclaration): + literal = "TooManyHostsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TooManyHostsFault") + kw["aname"] = "_TooManyHostsFault" + if ns0.TooManyHosts_Def not in ns0.TooManyHostsFault_Dec.__bases__: + bases = list(ns0.TooManyHostsFault_Dec.__bases__) + bases.insert(0, ns0.TooManyHosts_Def) + ns0.TooManyHostsFault_Dec.__bases__ = tuple(bases) + + ns0.TooManyHosts_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TooManyHostsFault_Dec_Holder" + + class TooManySnapshotLevelsFault_Dec(ElementDeclaration): + literal = "TooManySnapshotLevelsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","TooManySnapshotLevelsFault") + kw["aname"] = "_TooManySnapshotLevelsFault" + if ns0.TooManySnapshotLevels_Def not in ns0.TooManySnapshotLevelsFault_Dec.__bases__: + bases = list(ns0.TooManySnapshotLevelsFault_Dec.__bases__) + bases.insert(0, ns0.TooManySnapshotLevels_Def) + ns0.TooManySnapshotLevelsFault_Dec.__bases__ = tuple(bases) + + ns0.TooManySnapshotLevels_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "TooManySnapshotLevelsFault_Dec_Holder" + + class ToolsAlreadyUpgradedFault_Dec(ElementDeclaration): + literal = "ToolsAlreadyUpgradedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ToolsAlreadyUpgradedFault") + kw["aname"] = "_ToolsAlreadyUpgradedFault" + if ns0.ToolsAlreadyUpgraded_Def not in ns0.ToolsAlreadyUpgradedFault_Dec.__bases__: + bases = list(ns0.ToolsAlreadyUpgradedFault_Dec.__bases__) + bases.insert(0, ns0.ToolsAlreadyUpgraded_Def) + ns0.ToolsAlreadyUpgradedFault_Dec.__bases__ = tuple(bases) + + ns0.ToolsAlreadyUpgraded_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ToolsAlreadyUpgradedFault_Dec_Holder" + + class ToolsAutoUpgradeNotSupportedFault_Dec(ElementDeclaration): + literal = "ToolsAutoUpgradeNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ToolsAutoUpgradeNotSupportedFault") + kw["aname"] = "_ToolsAutoUpgradeNotSupportedFault" + if ns0.ToolsAutoUpgradeNotSupported_Def not in ns0.ToolsAutoUpgradeNotSupportedFault_Dec.__bases__: + bases = list(ns0.ToolsAutoUpgradeNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.ToolsAutoUpgradeNotSupported_Def) + ns0.ToolsAutoUpgradeNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.ToolsAutoUpgradeNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ToolsAutoUpgradeNotSupportedFault_Dec_Holder" + + class ToolsImageNotAvailableFault_Dec(ElementDeclaration): + literal = "ToolsImageNotAvailableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ToolsImageNotAvailableFault") + kw["aname"] = "_ToolsImageNotAvailableFault" + if ns0.ToolsImageNotAvailable_Def not in ns0.ToolsImageNotAvailableFault_Dec.__bases__: + bases = list(ns0.ToolsImageNotAvailableFault_Dec.__bases__) + bases.insert(0, ns0.ToolsImageNotAvailable_Def) + ns0.ToolsImageNotAvailableFault_Dec.__bases__ = tuple(bases) + + ns0.ToolsImageNotAvailable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ToolsImageNotAvailableFault_Dec_Holder" + + class ToolsImageSignatureCheckFailedFault_Dec(ElementDeclaration): + literal = "ToolsImageSignatureCheckFailedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ToolsImageSignatureCheckFailedFault") + kw["aname"] = "_ToolsImageSignatureCheckFailedFault" + if ns0.ToolsImageSignatureCheckFailed_Def not in ns0.ToolsImageSignatureCheckFailedFault_Dec.__bases__: + bases = list(ns0.ToolsImageSignatureCheckFailedFault_Dec.__bases__) + bases.insert(0, ns0.ToolsImageSignatureCheckFailed_Def) + ns0.ToolsImageSignatureCheckFailedFault_Dec.__bases__ = tuple(bases) + + ns0.ToolsImageSignatureCheckFailed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ToolsImageSignatureCheckFailedFault_Dec_Holder" + + class ToolsInstallationInProgressFault_Dec(ElementDeclaration): + literal = "ToolsInstallationInProgressFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ToolsInstallationInProgressFault") + kw["aname"] = "_ToolsInstallationInProgressFault" + if ns0.ToolsInstallationInProgress_Def not in ns0.ToolsInstallationInProgressFault_Dec.__bases__: + bases = list(ns0.ToolsInstallationInProgressFault_Dec.__bases__) + bases.insert(0, ns0.ToolsInstallationInProgress_Def) + ns0.ToolsInstallationInProgressFault_Dec.__bases__ = tuple(bases) + + ns0.ToolsInstallationInProgress_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ToolsInstallationInProgressFault_Dec_Holder" + + class ToolsUnavailableFault_Dec(ElementDeclaration): + literal = "ToolsUnavailableFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ToolsUnavailableFault") + kw["aname"] = "_ToolsUnavailableFault" + if ns0.ToolsUnavailable_Def not in ns0.ToolsUnavailableFault_Dec.__bases__: + bases = list(ns0.ToolsUnavailableFault_Dec.__bases__) + bases.insert(0, ns0.ToolsUnavailable_Def) + ns0.ToolsUnavailableFault_Dec.__bases__ = tuple(bases) + + ns0.ToolsUnavailable_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ToolsUnavailableFault_Dec_Holder" + + class ToolsUpgradeCancelledFault_Dec(ElementDeclaration): + literal = "ToolsUpgradeCancelledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ToolsUpgradeCancelledFault") + kw["aname"] = "_ToolsUpgradeCancelledFault" + if ns0.ToolsUpgradeCancelled_Def not in ns0.ToolsUpgradeCancelledFault_Dec.__bases__: + bases = list(ns0.ToolsUpgradeCancelledFault_Dec.__bases__) + bases.insert(0, ns0.ToolsUpgradeCancelled_Def) + ns0.ToolsUpgradeCancelledFault_Dec.__bases__ = tuple(bases) + + ns0.ToolsUpgradeCancelled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ToolsUpgradeCancelledFault_Dec_Holder" + + class UncommittedUndoableDiskFault_Dec(ElementDeclaration): + literal = "UncommittedUndoableDiskFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UncommittedUndoableDiskFault") + kw["aname"] = "_UncommittedUndoableDiskFault" + if ns0.UncommittedUndoableDisk_Def not in ns0.UncommittedUndoableDiskFault_Dec.__bases__: + bases = list(ns0.UncommittedUndoableDiskFault_Dec.__bases__) + bases.insert(0, ns0.UncommittedUndoableDisk_Def) + ns0.UncommittedUndoableDiskFault_Dec.__bases__ = tuple(bases) + + ns0.UncommittedUndoableDisk_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UncommittedUndoableDiskFault_Dec_Holder" + + class UnconfiguredPropertyValueFault_Dec(ElementDeclaration): + literal = "UnconfiguredPropertyValueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnconfiguredPropertyValueFault") + kw["aname"] = "_UnconfiguredPropertyValueFault" + if ns0.UnconfiguredPropertyValue_Def not in ns0.UnconfiguredPropertyValueFault_Dec.__bases__: + bases = list(ns0.UnconfiguredPropertyValueFault_Dec.__bases__) + bases.insert(0, ns0.UnconfiguredPropertyValue_Def) + ns0.UnconfiguredPropertyValueFault_Dec.__bases__ = tuple(bases) + + ns0.UnconfiguredPropertyValue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnconfiguredPropertyValueFault_Dec_Holder" + + class UncustomizableGuestFault_Dec(ElementDeclaration): + literal = "UncustomizableGuestFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UncustomizableGuestFault") + kw["aname"] = "_UncustomizableGuestFault" + if ns0.UncustomizableGuest_Def not in ns0.UncustomizableGuestFault_Dec.__bases__: + bases = list(ns0.UncustomizableGuestFault_Dec.__bases__) + bases.insert(0, ns0.UncustomizableGuest_Def) + ns0.UncustomizableGuestFault_Dec.__bases__ = tuple(bases) + + ns0.UncustomizableGuest_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UncustomizableGuestFault_Dec_Holder" + + class UnexpectedCustomizationFaultFault_Dec(ElementDeclaration): + literal = "UnexpectedCustomizationFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnexpectedCustomizationFaultFault") + kw["aname"] = "_UnexpectedCustomizationFaultFault" + if ns0.UnexpectedCustomizationFault_Def not in ns0.UnexpectedCustomizationFaultFault_Dec.__bases__: + bases = list(ns0.UnexpectedCustomizationFaultFault_Dec.__bases__) + bases.insert(0, ns0.UnexpectedCustomizationFault_Def) + ns0.UnexpectedCustomizationFaultFault_Dec.__bases__ = tuple(bases) + + ns0.UnexpectedCustomizationFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnexpectedCustomizationFaultFault_Dec_Holder" + + class UnrecognizedHostFault_Dec(ElementDeclaration): + literal = "UnrecognizedHostFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnrecognizedHostFault") + kw["aname"] = "_UnrecognizedHostFault" + if ns0.UnrecognizedHost_Def not in ns0.UnrecognizedHostFault_Dec.__bases__: + bases = list(ns0.UnrecognizedHostFault_Dec.__bases__) + bases.insert(0, ns0.UnrecognizedHost_Def) + ns0.UnrecognizedHostFault_Dec.__bases__ = tuple(bases) + + ns0.UnrecognizedHost_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnrecognizedHostFault_Dec_Holder" + + class UnsharedSwapVMotionNotSupportedFault_Dec(ElementDeclaration): + literal = "UnsharedSwapVMotionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnsharedSwapVMotionNotSupportedFault") + kw["aname"] = "_UnsharedSwapVMotionNotSupportedFault" + if ns0.UnsharedSwapVMotionNotSupported_Def not in ns0.UnsharedSwapVMotionNotSupportedFault_Dec.__bases__: + bases = list(ns0.UnsharedSwapVMotionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.UnsharedSwapVMotionNotSupported_Def) + ns0.UnsharedSwapVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.UnsharedSwapVMotionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnsharedSwapVMotionNotSupportedFault_Dec_Holder" + + class UnsupportedDatastoreFault_Dec(ElementDeclaration): + literal = "UnsupportedDatastoreFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnsupportedDatastoreFault") + kw["aname"] = "_UnsupportedDatastoreFault" + if ns0.UnsupportedDatastore_Def not in ns0.UnsupportedDatastoreFault_Dec.__bases__: + bases = list(ns0.UnsupportedDatastoreFault_Dec.__bases__) + bases.insert(0, ns0.UnsupportedDatastore_Def) + ns0.UnsupportedDatastoreFault_Dec.__bases__ = tuple(bases) + + ns0.UnsupportedDatastore_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedDatastoreFault_Dec_Holder" + + class UnsupportedGuestFault_Dec(ElementDeclaration): + literal = "UnsupportedGuestFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnsupportedGuestFault") + kw["aname"] = "_UnsupportedGuestFault" + if ns0.UnsupportedGuest_Def not in ns0.UnsupportedGuestFault_Dec.__bases__: + bases = list(ns0.UnsupportedGuestFault_Dec.__bases__) + bases.insert(0, ns0.UnsupportedGuest_Def) + ns0.UnsupportedGuestFault_Dec.__bases__ = tuple(bases) + + ns0.UnsupportedGuest_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedGuestFault_Dec_Holder" + + class UnsupportedVimApiVersionFault_Dec(ElementDeclaration): + literal = "UnsupportedVimApiVersionFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnsupportedVimApiVersionFault") + kw["aname"] = "_UnsupportedVimApiVersionFault" + if ns0.UnsupportedVimApiVersion_Def not in ns0.UnsupportedVimApiVersionFault_Dec.__bases__: + bases = list(ns0.UnsupportedVimApiVersionFault_Dec.__bases__) + bases.insert(0, ns0.UnsupportedVimApiVersion_Def) + ns0.UnsupportedVimApiVersionFault_Dec.__bases__ = tuple(bases) + + ns0.UnsupportedVimApiVersion_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedVimApiVersionFault_Dec_Holder" + + class UnsupportedVmxLocationFault_Dec(ElementDeclaration): + literal = "UnsupportedVmxLocationFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnsupportedVmxLocationFault") + kw["aname"] = "_UnsupportedVmxLocationFault" + if ns0.UnsupportedVmxLocation_Def not in ns0.UnsupportedVmxLocationFault_Dec.__bases__: + bases = list(ns0.UnsupportedVmxLocationFault_Dec.__bases__) + bases.insert(0, ns0.UnsupportedVmxLocation_Def) + ns0.UnsupportedVmxLocationFault_Dec.__bases__ = tuple(bases) + + ns0.UnsupportedVmxLocation_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedVmxLocationFault_Dec_Holder" + + class UnusedVirtualDiskBlocksNotScrubbedFault_Dec(ElementDeclaration): + literal = "UnusedVirtualDiskBlocksNotScrubbedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnusedVirtualDiskBlocksNotScrubbedFault") + kw["aname"] = "_UnusedVirtualDiskBlocksNotScrubbedFault" + if ns0.UnusedVirtualDiskBlocksNotScrubbed_Def not in ns0.UnusedVirtualDiskBlocksNotScrubbedFault_Dec.__bases__: + bases = list(ns0.UnusedVirtualDiskBlocksNotScrubbedFault_Dec.__bases__) + bases.insert(0, ns0.UnusedVirtualDiskBlocksNotScrubbed_Def) + ns0.UnusedVirtualDiskBlocksNotScrubbedFault_Dec.__bases__ = tuple(bases) + + ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnusedVirtualDiskBlocksNotScrubbedFault_Dec_Holder" + + class UserNotFoundFault_Dec(ElementDeclaration): + literal = "UserNotFoundFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UserNotFoundFault") + kw["aname"] = "_UserNotFoundFault" + if ns0.UserNotFound_Def not in ns0.UserNotFoundFault_Dec.__bases__: + bases = list(ns0.UserNotFoundFault_Dec.__bases__) + bases.insert(0, ns0.UserNotFound_Def) + ns0.UserNotFoundFault_Dec.__bases__ = tuple(bases) + + ns0.UserNotFound_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UserNotFoundFault_Dec_Holder" + + class VAppConfigFaultFault_Dec(ElementDeclaration): + literal = "VAppConfigFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VAppConfigFaultFault") + kw["aname"] = "_VAppConfigFaultFault" + if ns0.VAppConfigFault_Def not in ns0.VAppConfigFaultFault_Dec.__bases__: + bases = list(ns0.VAppConfigFaultFault_Dec.__bases__) + bases.insert(0, ns0.VAppConfigFault_Def) + ns0.VAppConfigFaultFault_Dec.__bases__ = tuple(bases) + + ns0.VAppConfigFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VAppConfigFaultFault_Dec_Holder" + + class VAppNotRunningFault_Dec(ElementDeclaration): + literal = "VAppNotRunningFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VAppNotRunningFault") + kw["aname"] = "_VAppNotRunningFault" + if ns0.VAppNotRunning_Def not in ns0.VAppNotRunningFault_Dec.__bases__: + bases = list(ns0.VAppNotRunningFault_Dec.__bases__) + bases.insert(0, ns0.VAppNotRunning_Def) + ns0.VAppNotRunningFault_Dec.__bases__ = tuple(bases) + + ns0.VAppNotRunning_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VAppNotRunningFault_Dec_Holder" + + class VAppPropertyFaultFault_Dec(ElementDeclaration): + literal = "VAppPropertyFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VAppPropertyFaultFault") + kw["aname"] = "_VAppPropertyFaultFault" + if ns0.VAppPropertyFault_Def not in ns0.VAppPropertyFaultFault_Dec.__bases__: + bases = list(ns0.VAppPropertyFaultFault_Dec.__bases__) + bases.insert(0, ns0.VAppPropertyFault_Def) + ns0.VAppPropertyFaultFault_Dec.__bases__ = tuple(bases) + + ns0.VAppPropertyFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VAppPropertyFaultFault_Dec_Holder" + + class VAppTaskInProgressFault_Dec(ElementDeclaration): + literal = "VAppTaskInProgressFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VAppTaskInProgressFault") + kw["aname"] = "_VAppTaskInProgressFault" + if ns0.VAppTaskInProgress_Def not in ns0.VAppTaskInProgressFault_Dec.__bases__: + bases = list(ns0.VAppTaskInProgressFault_Dec.__bases__) + bases.insert(0, ns0.VAppTaskInProgress_Def) + ns0.VAppTaskInProgressFault_Dec.__bases__ = tuple(bases) + + ns0.VAppTaskInProgress_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VAppTaskInProgressFault_Dec_Holder" + + class VMINotSupportedFault_Dec(ElementDeclaration): + literal = "VMINotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMINotSupportedFault") + kw["aname"] = "_VMINotSupportedFault" + if ns0.VMINotSupported_Def not in ns0.VMINotSupportedFault_Dec.__bases__: + bases = list(ns0.VMINotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.VMINotSupported_Def) + ns0.VMINotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.VMINotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMINotSupportedFault_Dec_Holder" + + class VMOnConflictDVPortFault_Dec(ElementDeclaration): + literal = "VMOnConflictDVPortFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMOnConflictDVPortFault") + kw["aname"] = "_VMOnConflictDVPortFault" + if ns0.VMOnConflictDVPort_Def not in ns0.VMOnConflictDVPortFault_Dec.__bases__: + bases = list(ns0.VMOnConflictDVPortFault_Dec.__bases__) + bases.insert(0, ns0.VMOnConflictDVPort_Def) + ns0.VMOnConflictDVPortFault_Dec.__bases__ = tuple(bases) + + ns0.VMOnConflictDVPort_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMOnConflictDVPortFault_Dec_Holder" + + class VMOnVirtualIntranetFault_Dec(ElementDeclaration): + literal = "VMOnVirtualIntranetFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMOnVirtualIntranetFault") + kw["aname"] = "_VMOnVirtualIntranetFault" + if ns0.VMOnVirtualIntranet_Def not in ns0.VMOnVirtualIntranetFault_Dec.__bases__: + bases = list(ns0.VMOnVirtualIntranetFault_Dec.__bases__) + bases.insert(0, ns0.VMOnVirtualIntranet_Def) + ns0.VMOnVirtualIntranetFault_Dec.__bases__ = tuple(bases) + + ns0.VMOnVirtualIntranet_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMOnVirtualIntranetFault_Dec_Holder" + + class VMotionInterfaceIssueFault_Dec(ElementDeclaration): + literal = "VMotionInterfaceIssueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMotionInterfaceIssueFault") + kw["aname"] = "_VMotionInterfaceIssueFault" + if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionInterfaceIssueFault_Dec.__bases__: + bases = list(ns0.VMotionInterfaceIssueFault_Dec.__bases__) + bases.insert(0, ns0.VMotionInterfaceIssue_Def) + ns0.VMotionInterfaceIssueFault_Dec.__bases__ = tuple(bases) + + ns0.VMotionInterfaceIssue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMotionInterfaceIssueFault_Dec_Holder" + + class VMotionLinkCapacityLowFault_Dec(ElementDeclaration): + literal = "VMotionLinkCapacityLowFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMotionLinkCapacityLowFault") + kw["aname"] = "_VMotionLinkCapacityLowFault" + if ns0.VMotionLinkCapacityLow_Def not in ns0.VMotionLinkCapacityLowFault_Dec.__bases__: + bases = list(ns0.VMotionLinkCapacityLowFault_Dec.__bases__) + bases.insert(0, ns0.VMotionLinkCapacityLow_Def) + ns0.VMotionLinkCapacityLowFault_Dec.__bases__ = tuple(bases) + + ns0.VMotionLinkCapacityLow_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMotionLinkCapacityLowFault_Dec_Holder" + + class VMotionLinkDownFault_Dec(ElementDeclaration): + literal = "VMotionLinkDownFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMotionLinkDownFault") + kw["aname"] = "_VMotionLinkDownFault" + if ns0.VMotionLinkDown_Def not in ns0.VMotionLinkDownFault_Dec.__bases__: + bases = list(ns0.VMotionLinkDownFault_Dec.__bases__) + bases.insert(0, ns0.VMotionLinkDown_Def) + ns0.VMotionLinkDownFault_Dec.__bases__ = tuple(bases) + + ns0.VMotionLinkDown_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMotionLinkDownFault_Dec_Holder" + + class VMotionNotConfiguredFault_Dec(ElementDeclaration): + literal = "VMotionNotConfiguredFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMotionNotConfiguredFault") + kw["aname"] = "_VMotionNotConfiguredFault" + if ns0.VMotionNotConfigured_Def not in ns0.VMotionNotConfiguredFault_Dec.__bases__: + bases = list(ns0.VMotionNotConfiguredFault_Dec.__bases__) + bases.insert(0, ns0.VMotionNotConfigured_Def) + ns0.VMotionNotConfiguredFault_Dec.__bases__ = tuple(bases) + + ns0.VMotionNotConfigured_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMotionNotConfiguredFault_Dec_Holder" + + class VMotionNotLicensedFault_Dec(ElementDeclaration): + literal = "VMotionNotLicensedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMotionNotLicensedFault") + kw["aname"] = "_VMotionNotLicensedFault" + if ns0.VMotionNotLicensed_Def not in ns0.VMotionNotLicensedFault_Dec.__bases__: + bases = list(ns0.VMotionNotLicensedFault_Dec.__bases__) + bases.insert(0, ns0.VMotionNotLicensed_Def) + ns0.VMotionNotLicensedFault_Dec.__bases__ = tuple(bases) + + ns0.VMotionNotLicensed_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMotionNotLicensedFault_Dec_Holder" + + class VMotionNotSupportedFault_Dec(ElementDeclaration): + literal = "VMotionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMotionNotSupportedFault") + kw["aname"] = "_VMotionNotSupportedFault" + if ns0.VMotionNotSupported_Def not in ns0.VMotionNotSupportedFault_Dec.__bases__: + bases = list(ns0.VMotionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.VMotionNotSupported_Def) + ns0.VMotionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.VMotionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMotionNotSupportedFault_Dec_Holder" + + class VMotionProtocolIncompatibleFault_Dec(ElementDeclaration): + literal = "VMotionProtocolIncompatibleFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VMotionProtocolIncompatibleFault") + kw["aname"] = "_VMotionProtocolIncompatibleFault" + if ns0.VMotionProtocolIncompatible_Def not in ns0.VMotionProtocolIncompatibleFault_Dec.__bases__: + bases = list(ns0.VMotionProtocolIncompatibleFault_Dec.__bases__) + bases.insert(0, ns0.VMotionProtocolIncompatible_Def) + ns0.VMotionProtocolIncompatibleFault_Dec.__bases__ = tuple(bases) + + ns0.VMotionProtocolIncompatible_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VMotionProtocolIncompatibleFault_Dec_Holder" + + class VimFaultFault_Dec(ElementDeclaration): + literal = "VimFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VimFaultFault") + kw["aname"] = "_VimFaultFault" + if ns0.VimFault_Def not in ns0.VimFaultFault_Dec.__bases__: + bases = list(ns0.VimFaultFault_Dec.__bases__) + bases.insert(0, ns0.VimFault_Def) + ns0.VimFaultFault_Dec.__bases__ = tuple(bases) + + ns0.VimFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VimFaultFault_Dec_Holder" + + class VirtualDiskBlocksNotFullyProvisionedFault_Dec(ElementDeclaration): + literal = "VirtualDiskBlocksNotFullyProvisionedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VirtualDiskBlocksNotFullyProvisionedFault") + kw["aname"] = "_VirtualDiskBlocksNotFullyProvisionedFault" + if ns0.VirtualDiskBlocksNotFullyProvisioned_Def not in ns0.VirtualDiskBlocksNotFullyProvisionedFault_Dec.__bases__: + bases = list(ns0.VirtualDiskBlocksNotFullyProvisionedFault_Dec.__bases__) + bases.insert(0, ns0.VirtualDiskBlocksNotFullyProvisioned_Def) + ns0.VirtualDiskBlocksNotFullyProvisionedFault_Dec.__bases__ = tuple(bases) + + ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VirtualDiskBlocksNotFullyProvisionedFault_Dec_Holder" + + class VirtualEthernetCardNotSupportedFault_Dec(ElementDeclaration): + literal = "VirtualEthernetCardNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VirtualEthernetCardNotSupportedFault") + kw["aname"] = "_VirtualEthernetCardNotSupportedFault" + if ns0.VirtualEthernetCardNotSupported_Def not in ns0.VirtualEthernetCardNotSupportedFault_Dec.__bases__: + bases = list(ns0.VirtualEthernetCardNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.VirtualEthernetCardNotSupported_Def) + ns0.VirtualEthernetCardNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.VirtualEthernetCardNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VirtualEthernetCardNotSupportedFault_Dec_Holder" + + class VirtualHardwareCompatibilityIssueFault_Dec(ElementDeclaration): + literal = "VirtualHardwareCompatibilityIssueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VirtualHardwareCompatibilityIssueFault") + kw["aname"] = "_VirtualHardwareCompatibilityIssueFault" + if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.VirtualHardwareCompatibilityIssueFault_Dec.__bases__: + bases = list(ns0.VirtualHardwareCompatibilityIssueFault_Dec.__bases__) + bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) + ns0.VirtualHardwareCompatibilityIssueFault_Dec.__bases__ = tuple(bases) + + ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VirtualHardwareCompatibilityIssueFault_Dec_Holder" + + class VirtualHardwareVersionNotSupportedFault_Dec(ElementDeclaration): + literal = "VirtualHardwareVersionNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VirtualHardwareVersionNotSupportedFault") + kw["aname"] = "_VirtualHardwareVersionNotSupportedFault" + if ns0.VirtualHardwareVersionNotSupported_Def not in ns0.VirtualHardwareVersionNotSupportedFault_Dec.__bases__: + bases = list(ns0.VirtualHardwareVersionNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.VirtualHardwareVersionNotSupported_Def) + ns0.VirtualHardwareVersionNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.VirtualHardwareVersionNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VirtualHardwareVersionNotSupportedFault_Dec_Holder" + + class VmAlreadyExistsInDatacenterFault_Dec(ElementDeclaration): + literal = "VmAlreadyExistsInDatacenterFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmAlreadyExistsInDatacenterFault") + kw["aname"] = "_VmAlreadyExistsInDatacenterFault" + if ns0.VmAlreadyExistsInDatacenter_Def not in ns0.VmAlreadyExistsInDatacenterFault_Dec.__bases__: + bases = list(ns0.VmAlreadyExistsInDatacenterFault_Dec.__bases__) + bases.insert(0, ns0.VmAlreadyExistsInDatacenter_Def) + ns0.VmAlreadyExistsInDatacenterFault_Dec.__bases__ = tuple(bases) + + ns0.VmAlreadyExistsInDatacenter_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmAlreadyExistsInDatacenterFault_Dec_Holder" + + class VmConfigFaultFault_Dec(ElementDeclaration): + literal = "VmConfigFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmConfigFaultFault") + kw["aname"] = "_VmConfigFaultFault" + if ns0.VmConfigFault_Def not in ns0.VmConfigFaultFault_Dec.__bases__: + bases = list(ns0.VmConfigFaultFault_Dec.__bases__) + bases.insert(0, ns0.VmConfigFault_Def) + ns0.VmConfigFaultFault_Dec.__bases__ = tuple(bases) + + ns0.VmConfigFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmConfigFaultFault_Dec_Holder" + + class VmConfigIncompatibleForFaultToleranceFault_Dec(ElementDeclaration): + literal = "VmConfigIncompatibleForFaultToleranceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmConfigIncompatibleForFaultToleranceFault") + kw["aname"] = "_VmConfigIncompatibleForFaultToleranceFault" + if ns0.VmConfigIncompatibleForFaultTolerance_Def not in ns0.VmConfigIncompatibleForFaultToleranceFault_Dec.__bases__: + bases = list(ns0.VmConfigIncompatibleForFaultToleranceFault_Dec.__bases__) + bases.insert(0, ns0.VmConfigIncompatibleForFaultTolerance_Def) + ns0.VmConfigIncompatibleForFaultToleranceFault_Dec.__bases__ = tuple(bases) + + ns0.VmConfigIncompatibleForFaultTolerance_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmConfigIncompatibleForFaultToleranceFault_Dec_Holder" + + class VmConfigIncompatibleForRecordReplayFault_Dec(ElementDeclaration): + literal = "VmConfigIncompatibleForRecordReplayFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmConfigIncompatibleForRecordReplayFault") + kw["aname"] = "_VmConfigIncompatibleForRecordReplayFault" + if ns0.VmConfigIncompatibleForRecordReplay_Def not in ns0.VmConfigIncompatibleForRecordReplayFault_Dec.__bases__: + bases = list(ns0.VmConfigIncompatibleForRecordReplayFault_Dec.__bases__) + bases.insert(0, ns0.VmConfigIncompatibleForRecordReplay_Def) + ns0.VmConfigIncompatibleForRecordReplayFault_Dec.__bases__ = tuple(bases) + + ns0.VmConfigIncompatibleForRecordReplay_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmConfigIncompatibleForRecordReplayFault_Dec_Holder" + + class VmFaultToleranceConfigIssueFault_Dec(ElementDeclaration): + literal = "VmFaultToleranceConfigIssueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmFaultToleranceConfigIssueFault") + kw["aname"] = "_VmFaultToleranceConfigIssueFault" + if ns0.VmFaultToleranceConfigIssue_Def not in ns0.VmFaultToleranceConfigIssueFault_Dec.__bases__: + bases = list(ns0.VmFaultToleranceConfigIssueFault_Dec.__bases__) + bases.insert(0, ns0.VmFaultToleranceConfigIssue_Def) + ns0.VmFaultToleranceConfigIssueFault_Dec.__bases__ = tuple(bases) + + ns0.VmFaultToleranceConfigIssue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceConfigIssueFault_Dec_Holder" + + class VmFaultToleranceInvalidFileBackingFault_Dec(ElementDeclaration): + literal = "VmFaultToleranceInvalidFileBackingFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmFaultToleranceInvalidFileBackingFault") + kw["aname"] = "_VmFaultToleranceInvalidFileBackingFault" + if ns0.VmFaultToleranceInvalidFileBacking_Def not in ns0.VmFaultToleranceInvalidFileBackingFault_Dec.__bases__: + bases = list(ns0.VmFaultToleranceInvalidFileBackingFault_Dec.__bases__) + bases.insert(0, ns0.VmFaultToleranceInvalidFileBacking_Def) + ns0.VmFaultToleranceInvalidFileBackingFault_Dec.__bases__ = tuple(bases) + + ns0.VmFaultToleranceInvalidFileBacking_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceInvalidFileBackingFault_Dec_Holder" + + class VmFaultToleranceIssueFault_Dec(ElementDeclaration): + literal = "VmFaultToleranceIssueFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmFaultToleranceIssueFault") + kw["aname"] = "_VmFaultToleranceIssueFault" + if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceIssueFault_Dec.__bases__: + bases = list(ns0.VmFaultToleranceIssueFault_Dec.__bases__) + bases.insert(0, ns0.VmFaultToleranceIssue_Def) + ns0.VmFaultToleranceIssueFault_Dec.__bases__ = tuple(bases) + + ns0.VmFaultToleranceIssue_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceIssueFault_Dec_Holder" + + class VmFaultToleranceOpIssuesListFault_Dec(ElementDeclaration): + literal = "VmFaultToleranceOpIssuesListFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmFaultToleranceOpIssuesListFault") + kw["aname"] = "_VmFaultToleranceOpIssuesListFault" + if ns0.VmFaultToleranceOpIssuesList_Def not in ns0.VmFaultToleranceOpIssuesListFault_Dec.__bases__: + bases = list(ns0.VmFaultToleranceOpIssuesListFault_Dec.__bases__) + bases.insert(0, ns0.VmFaultToleranceOpIssuesList_Def) + ns0.VmFaultToleranceOpIssuesListFault_Dec.__bases__ = tuple(bases) + + ns0.VmFaultToleranceOpIssuesList_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceOpIssuesListFault_Dec_Holder" + + class VmLimitLicenseFault_Dec(ElementDeclaration): + literal = "VmLimitLicenseFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmLimitLicenseFault") + kw["aname"] = "_VmLimitLicenseFault" + if ns0.VmLimitLicense_Def not in ns0.VmLimitLicenseFault_Dec.__bases__: + bases = list(ns0.VmLimitLicenseFault_Dec.__bases__) + bases.insert(0, ns0.VmLimitLicense_Def) + ns0.VmLimitLicenseFault_Dec.__bases__ = tuple(bases) + + ns0.VmLimitLicense_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmLimitLicenseFault_Dec_Holder" + + class VmPowerOnDisabledFault_Dec(ElementDeclaration): + literal = "VmPowerOnDisabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmPowerOnDisabledFault") + kw["aname"] = "_VmPowerOnDisabledFault" + if ns0.VmPowerOnDisabled_Def not in ns0.VmPowerOnDisabledFault_Dec.__bases__: + bases = list(ns0.VmPowerOnDisabledFault_Dec.__bases__) + bases.insert(0, ns0.VmPowerOnDisabled_Def) + ns0.VmPowerOnDisabledFault_Dec.__bases__ = tuple(bases) + + ns0.VmPowerOnDisabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmPowerOnDisabledFault_Dec_Holder" + + class VmToolsUpgradeFaultFault_Dec(ElementDeclaration): + literal = "VmToolsUpgradeFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmToolsUpgradeFaultFault") + kw["aname"] = "_VmToolsUpgradeFaultFault" + if ns0.VmToolsUpgradeFault_Def not in ns0.VmToolsUpgradeFaultFault_Dec.__bases__: + bases = list(ns0.VmToolsUpgradeFaultFault_Dec.__bases__) + bases.insert(0, ns0.VmToolsUpgradeFault_Def) + ns0.VmToolsUpgradeFaultFault_Dec.__bases__ = tuple(bases) + + ns0.VmToolsUpgradeFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmToolsUpgradeFaultFault_Dec_Holder" + + class VmValidateMaxDeviceFault_Dec(ElementDeclaration): + literal = "VmValidateMaxDeviceFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmValidateMaxDeviceFault") + kw["aname"] = "_VmValidateMaxDeviceFault" + if ns0.VmValidateMaxDevice_Def not in ns0.VmValidateMaxDeviceFault_Dec.__bases__: + bases = list(ns0.VmValidateMaxDeviceFault_Dec.__bases__) + bases.insert(0, ns0.VmValidateMaxDevice_Def) + ns0.VmValidateMaxDeviceFault_Dec.__bases__ = tuple(bases) + + ns0.VmValidateMaxDevice_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmValidateMaxDeviceFault_Dec_Holder" + + class VmWwnConflictFault_Dec(ElementDeclaration): + literal = "VmWwnConflictFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmWwnConflictFault") + kw["aname"] = "_VmWwnConflictFault" + if ns0.VmWwnConflict_Def not in ns0.VmWwnConflictFault_Dec.__bases__: + bases = list(ns0.VmWwnConflictFault_Dec.__bases__) + bases.insert(0, ns0.VmWwnConflict_Def) + ns0.VmWwnConflictFault_Dec.__bases__ = tuple(bases) + + ns0.VmWwnConflict_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmWwnConflictFault_Dec_Holder" + + class VmfsAlreadyMountedFault_Dec(ElementDeclaration): + literal = "VmfsAlreadyMountedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmfsAlreadyMountedFault") + kw["aname"] = "_VmfsAlreadyMountedFault" + if ns0.VmfsAlreadyMounted_Def not in ns0.VmfsAlreadyMountedFault_Dec.__bases__: + bases = list(ns0.VmfsAlreadyMountedFault_Dec.__bases__) + bases.insert(0, ns0.VmfsAlreadyMounted_Def) + ns0.VmfsAlreadyMountedFault_Dec.__bases__ = tuple(bases) + + ns0.VmfsAlreadyMounted_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmfsAlreadyMountedFault_Dec_Holder" + + class VmfsAmbiguousMountFault_Dec(ElementDeclaration): + literal = "VmfsAmbiguousMountFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmfsAmbiguousMountFault") + kw["aname"] = "_VmfsAmbiguousMountFault" + if ns0.VmfsAmbiguousMount_Def not in ns0.VmfsAmbiguousMountFault_Dec.__bases__: + bases = list(ns0.VmfsAmbiguousMountFault_Dec.__bases__) + bases.insert(0, ns0.VmfsAmbiguousMount_Def) + ns0.VmfsAmbiguousMountFault_Dec.__bases__ = tuple(bases) + + ns0.VmfsAmbiguousMount_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmfsAmbiguousMountFault_Dec_Holder" + + class VmfsMountFaultFault_Dec(ElementDeclaration): + literal = "VmfsMountFaultFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmfsMountFaultFault") + kw["aname"] = "_VmfsMountFaultFault" + if ns0.VmfsMountFault_Def not in ns0.VmfsMountFaultFault_Dec.__bases__: + bases = list(ns0.VmfsMountFaultFault_Dec.__bases__) + bases.insert(0, ns0.VmfsMountFault_Def) + ns0.VmfsMountFaultFault_Dec.__bases__ = tuple(bases) + + ns0.VmfsMountFault_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmfsMountFaultFault_Dec_Holder" + + class VmotionInterfaceNotEnabledFault_Dec(ElementDeclaration): + literal = "VmotionInterfaceNotEnabledFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VmotionInterfaceNotEnabledFault") + kw["aname"] = "_VmotionInterfaceNotEnabledFault" + if ns0.VmotionInterfaceNotEnabled_Def not in ns0.VmotionInterfaceNotEnabledFault_Dec.__bases__: + bases = list(ns0.VmotionInterfaceNotEnabledFault_Dec.__bases__) + bases.insert(0, ns0.VmotionInterfaceNotEnabled_Def) + ns0.VmotionInterfaceNotEnabledFault_Dec.__bases__ = tuple(bases) + + ns0.VmotionInterfaceNotEnabled_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VmotionInterfaceNotEnabledFault_Dec_Holder" + + class VolumeEditorErrorFault_Dec(ElementDeclaration): + literal = "VolumeEditorErrorFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VolumeEditorErrorFault") + kw["aname"] = "_VolumeEditorErrorFault" + if ns0.VolumeEditorError_Def not in ns0.VolumeEditorErrorFault_Dec.__bases__: + bases = list(ns0.VolumeEditorErrorFault_Dec.__bases__) + bases.insert(0, ns0.VolumeEditorError_Def) + ns0.VolumeEditorErrorFault_Dec.__bases__ = tuple(bases) + + ns0.VolumeEditorError_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VolumeEditorErrorFault_Dec_Holder" + + class WakeOnLanNotSupportedFault_Dec(ElementDeclaration): + literal = "WakeOnLanNotSupportedFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","WakeOnLanNotSupportedFault") + kw["aname"] = "_WakeOnLanNotSupportedFault" + if ns0.WakeOnLanNotSupported_Def not in ns0.WakeOnLanNotSupportedFault_Dec.__bases__: + bases = list(ns0.WakeOnLanNotSupportedFault_Dec.__bases__) + bases.insert(0, ns0.WakeOnLanNotSupported_Def) + ns0.WakeOnLanNotSupportedFault_Dec.__bases__ = tuple(bases) + + ns0.WakeOnLanNotSupported_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "WakeOnLanNotSupportedFault_Dec_Holder" + + class WakeOnLanNotSupportedByVmotionNICFault_Dec(ElementDeclaration): + literal = "WakeOnLanNotSupportedByVmotionNICFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","WakeOnLanNotSupportedByVmotionNICFault") + kw["aname"] = "_WakeOnLanNotSupportedByVmotionNICFault" + if ns0.WakeOnLanNotSupportedByVmotionNIC_Def not in ns0.WakeOnLanNotSupportedByVmotionNICFault_Dec.__bases__: + bases = list(ns0.WakeOnLanNotSupportedByVmotionNICFault_Dec.__bases__) + bases.insert(0, ns0.WakeOnLanNotSupportedByVmotionNIC_Def) + ns0.WakeOnLanNotSupportedByVmotionNICFault_Dec.__bases__ = tuple(bases) + + ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "WakeOnLanNotSupportedByVmotionNICFault_Dec_Holder" + + class WillModifyConfigCpuRequirementsFault_Dec(ElementDeclaration): + literal = "WillModifyConfigCpuRequirementsFault" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","WillModifyConfigCpuRequirementsFault") + kw["aname"] = "_WillModifyConfigCpuRequirementsFault" + if ns0.WillModifyConfigCpuRequirements_Def not in ns0.WillModifyConfigCpuRequirementsFault_Dec.__bases__: + bases = list(ns0.WillModifyConfigCpuRequirementsFault_Dec.__bases__) + bases.insert(0, ns0.WillModifyConfigCpuRequirements_Def) + ns0.WillModifyConfigCpuRequirementsFault_Dec.__bases__ = tuple(bases) + + ns0.WillModifyConfigCpuRequirements_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "WillModifyConfigCpuRequirementsFault_Dec_Holder" + + class ReconfigureAutostart_Dec(ElementDeclaration): + literal = "ReconfigureAutostart" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureAutostart") + kw["aname"] = "_ReconfigureAutostart" + if ns0.ReconfigureAutostartRequestType_Def not in ns0.ReconfigureAutostart_Dec.__bases__: + bases = list(ns0.ReconfigureAutostart_Dec.__bases__) + bases.insert(0, ns0.ReconfigureAutostartRequestType_Def) + ns0.ReconfigureAutostart_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureAutostartRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureAutostart_Dec_Holder" + + class ReconfigureAutostartResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureAutostartResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureAutostartResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureAutostartResponse") + kw["aname"] = "_ReconfigureAutostartResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureAutostartResponse_Holder" + self.pyclass = Holder + + class AutoStartPowerOn_Dec(ElementDeclaration): + literal = "AutoStartPowerOn" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AutoStartPowerOn") + kw["aname"] = "_AutoStartPowerOn" + if ns0.AutoStartPowerOnRequestType_Def not in ns0.AutoStartPowerOn_Dec.__bases__: + bases = list(ns0.AutoStartPowerOn_Dec.__bases__) + bases.insert(0, ns0.AutoStartPowerOnRequestType_Def) + ns0.AutoStartPowerOn_Dec.__bases__ = tuple(bases) + + ns0.AutoStartPowerOnRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AutoStartPowerOn_Dec_Holder" + + class AutoStartPowerOnResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AutoStartPowerOnResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AutoStartPowerOnResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AutoStartPowerOnResponse") + kw["aname"] = "_AutoStartPowerOnResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AutoStartPowerOnResponse_Holder" + self.pyclass = Holder + + class AutoStartPowerOff_Dec(ElementDeclaration): + literal = "AutoStartPowerOff" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AutoStartPowerOff") + kw["aname"] = "_AutoStartPowerOff" + if ns0.AutoStartPowerOffRequestType_Def not in ns0.AutoStartPowerOff_Dec.__bases__: + bases = list(ns0.AutoStartPowerOff_Dec.__bases__) + bases.insert(0, ns0.AutoStartPowerOffRequestType_Def) + ns0.AutoStartPowerOff_Dec.__bases__ = tuple(bases) + + ns0.AutoStartPowerOffRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AutoStartPowerOff_Dec_Holder" + + class AutoStartPowerOffResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AutoStartPowerOffResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AutoStartPowerOffResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AutoStartPowerOffResponse") + kw["aname"] = "_AutoStartPowerOffResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AutoStartPowerOffResponse_Holder" + self.pyclass = Holder + + class QueryBootDevices_Dec(ElementDeclaration): + literal = "QueryBootDevices" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryBootDevices") + kw["aname"] = "_QueryBootDevices" + if ns0.QueryBootDevicesRequestType_Def not in ns0.QueryBootDevices_Dec.__bases__: + bases = list(ns0.QueryBootDevices_Dec.__bases__) + bases.insert(0, ns0.QueryBootDevicesRequestType_Def) + ns0.QueryBootDevices_Dec.__bases__ = tuple(bases) + + ns0.QueryBootDevicesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryBootDevices_Dec_Holder" + + class QueryBootDevicesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryBootDevicesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryBootDevicesResponse_Dec.schema + TClist = [GTD("urn:vim25","HostBootDeviceInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryBootDevicesResponse") + kw["aname"] = "_QueryBootDevicesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryBootDevicesResponse_Holder" + self.pyclass = Holder + + class UpdateBootDevice_Dec(ElementDeclaration): + literal = "UpdateBootDevice" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateBootDevice") + kw["aname"] = "_UpdateBootDevice" + if ns0.UpdateBootDeviceRequestType_Def not in ns0.UpdateBootDevice_Dec.__bases__: + bases = list(ns0.UpdateBootDevice_Dec.__bases__) + bases.insert(0, ns0.UpdateBootDeviceRequestType_Def) + ns0.UpdateBootDevice_Dec.__bases__ = tuple(bases) + + ns0.UpdateBootDeviceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateBootDevice_Dec_Holder" + + class UpdateBootDeviceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateBootDeviceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateBootDeviceResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateBootDeviceResponse") + kw["aname"] = "_UpdateBootDeviceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateBootDeviceResponse_Holder" + self.pyclass = Holder + + class EnableHyperThreading_Dec(ElementDeclaration): + literal = "EnableHyperThreading" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnableHyperThreading") + kw["aname"] = "_EnableHyperThreading" + if ns0.EnableHyperThreadingRequestType_Def not in ns0.EnableHyperThreading_Dec.__bases__: + bases = list(ns0.EnableHyperThreading_Dec.__bases__) + bases.insert(0, ns0.EnableHyperThreadingRequestType_Def) + ns0.EnableHyperThreading_Dec.__bases__ = tuple(bases) + + ns0.EnableHyperThreadingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnableHyperThreading_Dec_Holder" + + class EnableHyperThreadingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnableHyperThreadingResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnableHyperThreadingResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","EnableHyperThreadingResponse") + kw["aname"] = "_EnableHyperThreadingResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "EnableHyperThreadingResponse_Holder" + self.pyclass = Holder + + class DisableHyperThreading_Dec(ElementDeclaration): + literal = "DisableHyperThreading" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisableHyperThreading") + kw["aname"] = "_DisableHyperThreading" + if ns0.DisableHyperThreadingRequestType_Def not in ns0.DisableHyperThreading_Dec.__bases__: + bases = list(ns0.DisableHyperThreading_Dec.__bases__) + bases.insert(0, ns0.DisableHyperThreadingRequestType_Def) + ns0.DisableHyperThreading_Dec.__bases__ = tuple(bases) + + ns0.DisableHyperThreadingRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisableHyperThreading_Dec_Holder" + + class DisableHyperThreadingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisableHyperThreadingResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisableHyperThreadingResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DisableHyperThreadingResponse") + kw["aname"] = "_DisableHyperThreadingResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DisableHyperThreadingResponse_Holder" + self.pyclass = Holder + + class SearchDatastore_Dec(ElementDeclaration): + literal = "SearchDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SearchDatastore") + kw["aname"] = "_SearchDatastore" + if ns0.SearchDatastoreRequestType_Def not in ns0.SearchDatastore_Dec.__bases__: + bases = list(ns0.SearchDatastore_Dec.__bases__) + bases.insert(0, ns0.SearchDatastoreRequestType_Def) + ns0.SearchDatastore_Dec.__bases__ = tuple(bases) + + ns0.SearchDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastore_Dec_Holder" + + class SearchDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SearchDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SearchDatastoreResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDatastoreBrowserSearchResults",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","SearchDatastoreResponse") + kw["aname"] = "_SearchDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "SearchDatastoreResponse_Holder" + self.pyclass = Holder + + class SearchDatastore_Task_Dec(ElementDeclaration): + literal = "SearchDatastore_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SearchDatastore_Task") + kw["aname"] = "_SearchDatastore_Task" + if ns0.SearchDatastoreRequestType_Def not in ns0.SearchDatastore_Task_Dec.__bases__: + bases = list(ns0.SearchDatastore_Task_Dec.__bases__) + bases.insert(0, ns0.SearchDatastoreRequestType_Def) + ns0.SearchDatastore_Task_Dec.__bases__ = tuple(bases) + + ns0.SearchDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastore_Task_Dec_Holder" + + class SearchDatastore_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SearchDatastore_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SearchDatastore_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","SearchDatastore_TaskResponse") + kw["aname"] = "_SearchDatastore_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "SearchDatastore_TaskResponse_Holder" + self.pyclass = Holder + + class SearchDatastoreSubFolders_Dec(ElementDeclaration): + literal = "SearchDatastoreSubFolders" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SearchDatastoreSubFolders") + kw["aname"] = "_SearchDatastoreSubFolders" + if ns0.SearchDatastoreSubFoldersRequestType_Def not in ns0.SearchDatastoreSubFolders_Dec.__bases__: + bases = list(ns0.SearchDatastoreSubFolders_Dec.__bases__) + bases.insert(0, ns0.SearchDatastoreSubFoldersRequestType_Def) + ns0.SearchDatastoreSubFolders_Dec.__bases__ = tuple(bases) + + ns0.SearchDatastoreSubFoldersRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastoreSubFolders_Dec_Holder" + + class SearchDatastoreSubFoldersResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SearchDatastoreSubFoldersResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SearchDatastoreSubFoldersResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDatastoreBrowserSearchResults",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","SearchDatastoreSubFoldersResponse") + kw["aname"] = "_SearchDatastoreSubFoldersResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "SearchDatastoreSubFoldersResponse_Holder" + self.pyclass = Holder + + class SearchDatastoreSubFolders_Task_Dec(ElementDeclaration): + literal = "SearchDatastoreSubFolders_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SearchDatastoreSubFolders_Task") + kw["aname"] = "_SearchDatastoreSubFolders_Task" + if ns0.SearchDatastoreSubFoldersRequestType_Def not in ns0.SearchDatastoreSubFolders_Task_Dec.__bases__: + bases = list(ns0.SearchDatastoreSubFolders_Task_Dec.__bases__) + bases.insert(0, ns0.SearchDatastoreSubFoldersRequestType_Def) + ns0.SearchDatastoreSubFolders_Task_Dec.__bases__ = tuple(bases) + + ns0.SearchDatastoreSubFoldersRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastoreSubFolders_Task_Dec_Holder" + + class SearchDatastoreSubFolders_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SearchDatastoreSubFolders_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SearchDatastoreSubFolders_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","SearchDatastoreSubFolders_TaskResponse") + kw["aname"] = "_SearchDatastoreSubFolders_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "SearchDatastoreSubFolders_TaskResponse_Holder" + self.pyclass = Holder + + class DeleteFile_Dec(ElementDeclaration): + literal = "DeleteFile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeleteFile") + kw["aname"] = "_DeleteFile" + if ns0.DeleteFileRequestType_Def not in ns0.DeleteFile_Dec.__bases__: + bases = list(ns0.DeleteFile_Dec.__bases__) + bases.insert(0, ns0.DeleteFileRequestType_Def) + ns0.DeleteFile_Dec.__bases__ = tuple(bases) + + ns0.DeleteFileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeleteFile_Dec_Holder" + + class DeleteFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DeleteFileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DeleteFileResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DeleteFileResponse") + kw["aname"] = "_DeleteFileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DeleteFileResponse_Holder" + self.pyclass = Holder + + class UpdateLocalSwapDatastore_Dec(ElementDeclaration): + literal = "UpdateLocalSwapDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateLocalSwapDatastore") + kw["aname"] = "_UpdateLocalSwapDatastore" + if ns0.UpdateLocalSwapDatastoreRequestType_Def not in ns0.UpdateLocalSwapDatastore_Dec.__bases__: + bases = list(ns0.UpdateLocalSwapDatastore_Dec.__bases__) + bases.insert(0, ns0.UpdateLocalSwapDatastoreRequestType_Def) + ns0.UpdateLocalSwapDatastore_Dec.__bases__ = tuple(bases) + + ns0.UpdateLocalSwapDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateLocalSwapDatastore_Dec_Holder" + + class UpdateLocalSwapDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateLocalSwapDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateLocalSwapDatastoreResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateLocalSwapDatastoreResponse") + kw["aname"] = "_UpdateLocalSwapDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateLocalSwapDatastoreResponse_Holder" + self.pyclass = Holder + + class QueryAvailableDisksForVmfs_Dec(ElementDeclaration): + literal = "QueryAvailableDisksForVmfs" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryAvailableDisksForVmfs") + kw["aname"] = "_QueryAvailableDisksForVmfs" + if ns0.QueryAvailableDisksForVmfsRequestType_Def not in ns0.QueryAvailableDisksForVmfs_Dec.__bases__: + bases = list(ns0.QueryAvailableDisksForVmfs_Dec.__bases__) + bases.insert(0, ns0.QueryAvailableDisksForVmfsRequestType_Def) + ns0.QueryAvailableDisksForVmfs_Dec.__bases__ = tuple(bases) + + ns0.QueryAvailableDisksForVmfsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailableDisksForVmfs_Dec_Holder" + + class QueryAvailableDisksForVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryAvailableDisksForVmfsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryAvailableDisksForVmfsResponse_Dec.schema + TClist = [GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryAvailableDisksForVmfsResponse") + kw["aname"] = "_QueryAvailableDisksForVmfsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryAvailableDisksForVmfsResponse_Holder" + self.pyclass = Holder + + class QueryVmfsDatastoreCreateOptions_Dec(ElementDeclaration): + literal = "QueryVmfsDatastoreCreateOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVmfsDatastoreCreateOptions") + kw["aname"] = "_QueryVmfsDatastoreCreateOptions" + if ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def not in ns0.QueryVmfsDatastoreCreateOptions_Dec.__bases__: + bases = list(ns0.QueryVmfsDatastoreCreateOptions_Dec.__bases__) + bases.insert(0, ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def) + ns0.QueryVmfsDatastoreCreateOptions_Dec.__bases__ = tuple(bases) + + ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVmfsDatastoreCreateOptions_Dec_Holder" + + class QueryVmfsDatastoreCreateOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVmfsDatastoreCreateOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVmfsDatastoreCreateOptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVmfsDatastoreCreateOptionsResponse") + kw["aname"] = "_QueryVmfsDatastoreCreateOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryVmfsDatastoreCreateOptionsResponse_Holder" + self.pyclass = Holder + + class CreateVmfsDatastore_Dec(ElementDeclaration): + literal = "CreateVmfsDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateVmfsDatastore") + kw["aname"] = "_CreateVmfsDatastore" + if ns0.CreateVmfsDatastoreRequestType_Def not in ns0.CreateVmfsDatastore_Dec.__bases__: + bases = list(ns0.CreateVmfsDatastore_Dec.__bases__) + bases.insert(0, ns0.CreateVmfsDatastoreRequestType_Def) + ns0.CreateVmfsDatastore_Dec.__bases__ = tuple(bases) + + ns0.CreateVmfsDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateVmfsDatastore_Dec_Holder" + + class CreateVmfsDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateVmfsDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateVmfsDatastoreResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateVmfsDatastoreResponse") + kw["aname"] = "_CreateVmfsDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateVmfsDatastoreResponse_Holder" + self.pyclass = Holder + + class QueryVmfsDatastoreExtendOptions_Dec(ElementDeclaration): + literal = "QueryVmfsDatastoreExtendOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExtendOptions") + kw["aname"] = "_QueryVmfsDatastoreExtendOptions" + if ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def not in ns0.QueryVmfsDatastoreExtendOptions_Dec.__bases__: + bases = list(ns0.QueryVmfsDatastoreExtendOptions_Dec.__bases__) + bases.insert(0, ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def) + ns0.QueryVmfsDatastoreExtendOptions_Dec.__bases__ = tuple(bases) + + ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVmfsDatastoreExtendOptions_Dec_Holder" + + class QueryVmfsDatastoreExtendOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVmfsDatastoreExtendOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVmfsDatastoreExtendOptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExtendOptionsResponse") + kw["aname"] = "_QueryVmfsDatastoreExtendOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryVmfsDatastoreExtendOptionsResponse_Holder" + self.pyclass = Holder + + class QueryVmfsDatastoreExpandOptions_Dec(ElementDeclaration): + literal = "QueryVmfsDatastoreExpandOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExpandOptions") + kw["aname"] = "_QueryVmfsDatastoreExpandOptions" + if ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def not in ns0.QueryVmfsDatastoreExpandOptions_Dec.__bases__: + bases = list(ns0.QueryVmfsDatastoreExpandOptions_Dec.__bases__) + bases.insert(0, ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def) + ns0.QueryVmfsDatastoreExpandOptions_Dec.__bases__ = tuple(bases) + + ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVmfsDatastoreExpandOptions_Dec_Holder" + + class QueryVmfsDatastoreExpandOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVmfsDatastoreExpandOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVmfsDatastoreExpandOptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExpandOptionsResponse") + kw["aname"] = "_QueryVmfsDatastoreExpandOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryVmfsDatastoreExpandOptionsResponse_Holder" + self.pyclass = Holder + + class ExtendVmfsDatastore_Dec(ElementDeclaration): + literal = "ExtendVmfsDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExtendVmfsDatastore") + kw["aname"] = "_ExtendVmfsDatastore" + if ns0.ExtendVmfsDatastoreRequestType_Def not in ns0.ExtendVmfsDatastore_Dec.__bases__: + bases = list(ns0.ExtendVmfsDatastore_Dec.__bases__) + bases.insert(0, ns0.ExtendVmfsDatastoreRequestType_Def) + ns0.ExtendVmfsDatastore_Dec.__bases__ = tuple(bases) + + ns0.ExtendVmfsDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExtendVmfsDatastore_Dec_Holder" + + class ExtendVmfsDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExtendVmfsDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExtendVmfsDatastoreResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ExtendVmfsDatastoreResponse") + kw["aname"] = "_ExtendVmfsDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ExtendVmfsDatastoreResponse_Holder" + self.pyclass = Holder + + class ExpandVmfsDatastore_Dec(ElementDeclaration): + literal = "ExpandVmfsDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExpandVmfsDatastore") + kw["aname"] = "_ExpandVmfsDatastore" + if ns0.ExpandVmfsDatastoreRequestType_Def not in ns0.ExpandVmfsDatastore_Dec.__bases__: + bases = list(ns0.ExpandVmfsDatastore_Dec.__bases__) + bases.insert(0, ns0.ExpandVmfsDatastoreRequestType_Def) + ns0.ExpandVmfsDatastore_Dec.__bases__ = tuple(bases) + + ns0.ExpandVmfsDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExpandVmfsDatastore_Dec_Holder" + + class ExpandVmfsDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExpandVmfsDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExpandVmfsDatastoreResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ExpandVmfsDatastoreResponse") + kw["aname"] = "_ExpandVmfsDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ExpandVmfsDatastoreResponse_Holder" + self.pyclass = Holder + + class CreateNasDatastore_Dec(ElementDeclaration): + literal = "CreateNasDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateNasDatastore") + kw["aname"] = "_CreateNasDatastore" + if ns0.CreateNasDatastoreRequestType_Def not in ns0.CreateNasDatastore_Dec.__bases__: + bases = list(ns0.CreateNasDatastore_Dec.__bases__) + bases.insert(0, ns0.CreateNasDatastoreRequestType_Def) + ns0.CreateNasDatastore_Dec.__bases__ = tuple(bases) + + ns0.CreateNasDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateNasDatastore_Dec_Holder" + + class CreateNasDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateNasDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateNasDatastoreResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateNasDatastoreResponse") + kw["aname"] = "_CreateNasDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateNasDatastoreResponse_Holder" + self.pyclass = Holder + + class CreateLocalDatastore_Dec(ElementDeclaration): + literal = "CreateLocalDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateLocalDatastore") + kw["aname"] = "_CreateLocalDatastore" + if ns0.CreateLocalDatastoreRequestType_Def not in ns0.CreateLocalDatastore_Dec.__bases__: + bases = list(ns0.CreateLocalDatastore_Dec.__bases__) + bases.insert(0, ns0.CreateLocalDatastoreRequestType_Def) + ns0.CreateLocalDatastore_Dec.__bases__ = tuple(bases) + + ns0.CreateLocalDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateLocalDatastore_Dec_Holder" + + class CreateLocalDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateLocalDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateLocalDatastoreResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateLocalDatastoreResponse") + kw["aname"] = "_CreateLocalDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateLocalDatastoreResponse_Holder" + self.pyclass = Holder + + class RemoveDatastore_Dec(ElementDeclaration): + literal = "RemoveDatastore" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveDatastore") + kw["aname"] = "_RemoveDatastore" + if ns0.RemoveDatastoreRequestType_Def not in ns0.RemoveDatastore_Dec.__bases__: + bases = list(ns0.RemoveDatastore_Dec.__bases__) + bases.insert(0, ns0.RemoveDatastoreRequestType_Def) + ns0.RemoveDatastore_Dec.__bases__ = tuple(bases) + + ns0.RemoveDatastoreRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveDatastore_Dec_Holder" + + class RemoveDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveDatastoreResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveDatastoreResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveDatastoreResponse") + kw["aname"] = "_RemoveDatastoreResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveDatastoreResponse_Holder" + self.pyclass = Holder + + class ConfigureDatastorePrincipal_Dec(ElementDeclaration): + literal = "ConfigureDatastorePrincipal" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ConfigureDatastorePrincipal") + kw["aname"] = "_ConfigureDatastorePrincipal" + if ns0.ConfigureDatastorePrincipalRequestType_Def not in ns0.ConfigureDatastorePrincipal_Dec.__bases__: + bases = list(ns0.ConfigureDatastorePrincipal_Dec.__bases__) + bases.insert(0, ns0.ConfigureDatastorePrincipalRequestType_Def) + ns0.ConfigureDatastorePrincipal_Dec.__bases__ = tuple(bases) + + ns0.ConfigureDatastorePrincipalRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ConfigureDatastorePrincipal_Dec_Holder" + + class ConfigureDatastorePrincipalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ConfigureDatastorePrincipalResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ConfigureDatastorePrincipalResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ConfigureDatastorePrincipalResponse") + kw["aname"] = "_ConfigureDatastorePrincipalResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ConfigureDatastorePrincipalResponse_Holder" + self.pyclass = Holder + + class QueryUnresolvedVmfsVolumes_Dec(ElementDeclaration): + literal = "QueryUnresolvedVmfsVolumes" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolumes") + kw["aname"] = "_QueryUnresolvedVmfsVolumes" + if ns0.QueryUnresolvedVmfsVolumesRequestType_Def not in ns0.QueryUnresolvedVmfsVolumes_Dec.__bases__: + bases = list(ns0.QueryUnresolvedVmfsVolumes_Dec.__bases__) + bases.insert(0, ns0.QueryUnresolvedVmfsVolumesRequestType_Def) + ns0.QueryUnresolvedVmfsVolumes_Dec.__bases__ = tuple(bases) + + ns0.QueryUnresolvedVmfsVolumesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryUnresolvedVmfsVolumes_Dec_Holder" + + class QueryUnresolvedVmfsVolumesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryUnresolvedVmfsVolumesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryUnresolvedVmfsVolumesResponse_Dec.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsVolume",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolumesResponse") + kw["aname"] = "_QueryUnresolvedVmfsVolumesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryUnresolvedVmfsVolumesResponse_Holder" + self.pyclass = Holder + + class ResignatureUnresolvedVmfsVolume_Dec(ElementDeclaration): + literal = "ResignatureUnresolvedVmfsVolume" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolume") + kw["aname"] = "_ResignatureUnresolvedVmfsVolume" + if ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def not in ns0.ResignatureUnresolvedVmfsVolume_Dec.__bases__: + bases = list(ns0.ResignatureUnresolvedVmfsVolume_Dec.__bases__) + bases.insert(0, ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def) + ns0.ResignatureUnresolvedVmfsVolume_Dec.__bases__ = tuple(bases) + + ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResignatureUnresolvedVmfsVolume_Dec_Holder" + + class ResignatureUnresolvedVmfsVolumeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResignatureUnresolvedVmfsVolumeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResignatureUnresolvedVmfsVolumeResponse_Dec.schema + TClist = [GTD("urn:vim25","HostResignatureRescanResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolumeResponse") + kw["aname"] = "_ResignatureUnresolvedVmfsVolumeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ResignatureUnresolvedVmfsVolumeResponse_Holder" + self.pyclass = Holder + + class ResignatureUnresolvedVmfsVolume_Task_Dec(ElementDeclaration): + literal = "ResignatureUnresolvedVmfsVolume_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolume_Task") + kw["aname"] = "_ResignatureUnresolvedVmfsVolume_Task" + if ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def not in ns0.ResignatureUnresolvedVmfsVolume_Task_Dec.__bases__: + bases = list(ns0.ResignatureUnresolvedVmfsVolume_Task_Dec.__bases__) + bases.insert(0, ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def) + ns0.ResignatureUnresolvedVmfsVolume_Task_Dec.__bases__ = tuple(bases) + + ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResignatureUnresolvedVmfsVolume_Task_Dec_Holder" + + class ResignatureUnresolvedVmfsVolume_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResignatureUnresolvedVmfsVolume_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResignatureUnresolvedVmfsVolume_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolume_TaskResponse") + kw["aname"] = "_ResignatureUnresolvedVmfsVolume_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ResignatureUnresolvedVmfsVolume_TaskResponse_Holder" + self.pyclass = Holder + + class UpdateDateTimeConfig_Dec(ElementDeclaration): + literal = "UpdateDateTimeConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateDateTimeConfig") + kw["aname"] = "_UpdateDateTimeConfig" + if ns0.UpdateDateTimeConfigRequestType_Def not in ns0.UpdateDateTimeConfig_Dec.__bases__: + bases = list(ns0.UpdateDateTimeConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateDateTimeConfigRequestType_Def) + ns0.UpdateDateTimeConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateDateTimeConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateDateTimeConfig_Dec_Holder" + + class UpdateDateTimeConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateDateTimeConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateDateTimeConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateDateTimeConfigResponse") + kw["aname"] = "_UpdateDateTimeConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateDateTimeConfigResponse_Holder" + self.pyclass = Holder + + class QueryAvailableTimeZones_Dec(ElementDeclaration): + literal = "QueryAvailableTimeZones" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryAvailableTimeZones") + kw["aname"] = "_QueryAvailableTimeZones" + if ns0.QueryAvailableTimeZonesRequestType_Def not in ns0.QueryAvailableTimeZones_Dec.__bases__: + bases = list(ns0.QueryAvailableTimeZones_Dec.__bases__) + bases.insert(0, ns0.QueryAvailableTimeZonesRequestType_Def) + ns0.QueryAvailableTimeZones_Dec.__bases__ = tuple(bases) + + ns0.QueryAvailableTimeZonesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailableTimeZones_Dec_Holder" + + class QueryAvailableTimeZonesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryAvailableTimeZonesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryAvailableTimeZonesResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDateTimeSystemTimeZone",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryAvailableTimeZonesResponse") + kw["aname"] = "_QueryAvailableTimeZonesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryAvailableTimeZonesResponse_Holder" + self.pyclass = Holder + + class QueryDateTime_Dec(ElementDeclaration): + literal = "QueryDateTime" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryDateTime") + kw["aname"] = "_QueryDateTime" + if ns0.QueryDateTimeRequestType_Def not in ns0.QueryDateTime_Dec.__bases__: + bases = list(ns0.QueryDateTime_Dec.__bases__) + bases.insert(0, ns0.QueryDateTimeRequestType_Def) + ns0.QueryDateTime_Dec.__bases__ = tuple(bases) + + ns0.QueryDateTimeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryDateTime_Dec_Holder" + + class QueryDateTimeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryDateTimeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryDateTimeResponse_Dec.schema + TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryDateTimeResponse") + kw["aname"] = "_QueryDateTimeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryDateTimeResponse_Holder" + self.pyclass = Holder + + class UpdateDateTime_Dec(ElementDeclaration): + literal = "UpdateDateTime" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateDateTime") + kw["aname"] = "_UpdateDateTime" + if ns0.UpdateDateTimeRequestType_Def not in ns0.UpdateDateTime_Dec.__bases__: + bases = list(ns0.UpdateDateTime_Dec.__bases__) + bases.insert(0, ns0.UpdateDateTimeRequestType_Def) + ns0.UpdateDateTime_Dec.__bases__ = tuple(bases) + + ns0.UpdateDateTimeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateDateTime_Dec_Holder" + + class UpdateDateTimeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateDateTimeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateDateTimeResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateDateTimeResponse") + kw["aname"] = "_UpdateDateTimeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateDateTimeResponse_Holder" + self.pyclass = Holder + + class RefreshDateTimeSystem_Dec(ElementDeclaration): + literal = "RefreshDateTimeSystem" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshDateTimeSystem") + kw["aname"] = "_RefreshDateTimeSystem" + if ns0.RefreshDateTimeSystemRequestType_Def not in ns0.RefreshDateTimeSystem_Dec.__bases__: + bases = list(ns0.RefreshDateTimeSystem_Dec.__bases__) + bases.insert(0, ns0.RefreshDateTimeSystemRequestType_Def) + ns0.RefreshDateTimeSystem_Dec.__bases__ = tuple(bases) + + ns0.RefreshDateTimeSystemRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshDateTimeSystem_Dec_Holder" + + class RefreshDateTimeSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshDateTimeSystemResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshDateTimeSystemResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshDateTimeSystemResponse") + kw["aname"] = "_RefreshDateTimeSystemResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshDateTimeSystemResponse_Holder" + self.pyclass = Holder + + class QueryAvailablePartition_Dec(ElementDeclaration): + literal = "QueryAvailablePartition" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryAvailablePartition") + kw["aname"] = "_QueryAvailablePartition" + if ns0.QueryAvailablePartitionRequestType_Def not in ns0.QueryAvailablePartition_Dec.__bases__: + bases = list(ns0.QueryAvailablePartition_Dec.__bases__) + bases.insert(0, ns0.QueryAvailablePartitionRequestType_Def) + ns0.QueryAvailablePartition_Dec.__bases__ = tuple(bases) + + ns0.QueryAvailablePartitionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailablePartition_Dec_Holder" + + class QueryAvailablePartitionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryAvailablePartitionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryAvailablePartitionResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDiagnosticPartition",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryAvailablePartitionResponse") + kw["aname"] = "_QueryAvailablePartitionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryAvailablePartitionResponse_Holder" + self.pyclass = Holder + + class SelectActivePartition_Dec(ElementDeclaration): + literal = "SelectActivePartition" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SelectActivePartition") + kw["aname"] = "_SelectActivePartition" + if ns0.SelectActivePartitionRequestType_Def not in ns0.SelectActivePartition_Dec.__bases__: + bases = list(ns0.SelectActivePartition_Dec.__bases__) + bases.insert(0, ns0.SelectActivePartitionRequestType_Def) + ns0.SelectActivePartition_Dec.__bases__ = tuple(bases) + + ns0.SelectActivePartitionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SelectActivePartition_Dec_Holder" + + class SelectActivePartitionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SelectActivePartitionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SelectActivePartitionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SelectActivePartitionResponse") + kw["aname"] = "_SelectActivePartitionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SelectActivePartitionResponse_Holder" + self.pyclass = Holder + + class QueryPartitionCreateOptions_Dec(ElementDeclaration): + literal = "QueryPartitionCreateOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPartitionCreateOptions") + kw["aname"] = "_QueryPartitionCreateOptions" + if ns0.QueryPartitionCreateOptionsRequestType_Def not in ns0.QueryPartitionCreateOptions_Dec.__bases__: + bases = list(ns0.QueryPartitionCreateOptions_Dec.__bases__) + bases.insert(0, ns0.QueryPartitionCreateOptionsRequestType_Def) + ns0.QueryPartitionCreateOptions_Dec.__bases__ = tuple(bases) + + ns0.QueryPartitionCreateOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPartitionCreateOptions_Dec_Holder" + + class QueryPartitionCreateOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPartitionCreateOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPartitionCreateOptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDiagnosticPartitionCreateOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPartitionCreateOptionsResponse") + kw["aname"] = "_QueryPartitionCreateOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryPartitionCreateOptionsResponse_Holder" + self.pyclass = Holder + + class QueryPartitionCreateDesc_Dec(ElementDeclaration): + literal = "QueryPartitionCreateDesc" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPartitionCreateDesc") + kw["aname"] = "_QueryPartitionCreateDesc" + if ns0.QueryPartitionCreateDescRequestType_Def not in ns0.QueryPartitionCreateDesc_Dec.__bases__: + bases = list(ns0.QueryPartitionCreateDesc_Dec.__bases__) + bases.insert(0, ns0.QueryPartitionCreateDescRequestType_Def) + ns0.QueryPartitionCreateDesc_Dec.__bases__ = tuple(bases) + + ns0.QueryPartitionCreateDescRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPartitionCreateDesc_Dec_Holder" + + class QueryPartitionCreateDescResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPartitionCreateDescResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPartitionCreateDescResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDiagnosticPartitionCreateDescription",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPartitionCreateDescResponse") + kw["aname"] = "_QueryPartitionCreateDescResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryPartitionCreateDescResponse_Holder" + self.pyclass = Holder + + class CreateDiagnosticPartition_Dec(ElementDeclaration): + literal = "CreateDiagnosticPartition" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateDiagnosticPartition") + kw["aname"] = "_CreateDiagnosticPartition" + if ns0.CreateDiagnosticPartitionRequestType_Def not in ns0.CreateDiagnosticPartition_Dec.__bases__: + bases = list(ns0.CreateDiagnosticPartition_Dec.__bases__) + bases.insert(0, ns0.CreateDiagnosticPartitionRequestType_Def) + ns0.CreateDiagnosticPartition_Dec.__bases__ = tuple(bases) + + ns0.CreateDiagnosticPartitionRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateDiagnosticPartition_Dec_Holder" + + class CreateDiagnosticPartitionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateDiagnosticPartitionResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateDiagnosticPartitionResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CreateDiagnosticPartitionResponse") + kw["aname"] = "_CreateDiagnosticPartitionResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CreateDiagnosticPartitionResponse_Holder" + self.pyclass = Holder + + class UpdateDefaultPolicy_Dec(ElementDeclaration): + literal = "UpdateDefaultPolicy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateDefaultPolicy") + kw["aname"] = "_UpdateDefaultPolicy" + if ns0.UpdateDefaultPolicyRequestType_Def not in ns0.UpdateDefaultPolicy_Dec.__bases__: + bases = list(ns0.UpdateDefaultPolicy_Dec.__bases__) + bases.insert(0, ns0.UpdateDefaultPolicyRequestType_Def) + ns0.UpdateDefaultPolicy_Dec.__bases__ = tuple(bases) + + ns0.UpdateDefaultPolicyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateDefaultPolicy_Dec_Holder" + + class UpdateDefaultPolicyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateDefaultPolicyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateDefaultPolicyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateDefaultPolicyResponse") + kw["aname"] = "_UpdateDefaultPolicyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateDefaultPolicyResponse_Holder" + self.pyclass = Holder + + class EnableRuleset_Dec(ElementDeclaration): + literal = "EnableRuleset" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnableRuleset") + kw["aname"] = "_EnableRuleset" + if ns0.EnableRulesetRequestType_Def not in ns0.EnableRuleset_Dec.__bases__: + bases = list(ns0.EnableRuleset_Dec.__bases__) + bases.insert(0, ns0.EnableRulesetRequestType_Def) + ns0.EnableRuleset_Dec.__bases__ = tuple(bases) + + ns0.EnableRulesetRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnableRuleset_Dec_Holder" + + class EnableRulesetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnableRulesetResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnableRulesetResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","EnableRulesetResponse") + kw["aname"] = "_EnableRulesetResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "EnableRulesetResponse_Holder" + self.pyclass = Holder + + class DisableRuleset_Dec(ElementDeclaration): + literal = "DisableRuleset" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisableRuleset") + kw["aname"] = "_DisableRuleset" + if ns0.DisableRulesetRequestType_Def not in ns0.DisableRuleset_Dec.__bases__: + bases = list(ns0.DisableRuleset_Dec.__bases__) + bases.insert(0, ns0.DisableRulesetRequestType_Def) + ns0.DisableRuleset_Dec.__bases__ = tuple(bases) + + ns0.DisableRulesetRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisableRuleset_Dec_Holder" + + class DisableRulesetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisableRulesetResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisableRulesetResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DisableRulesetResponse") + kw["aname"] = "_DisableRulesetResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DisableRulesetResponse_Holder" + self.pyclass = Holder + + class RefreshFirewall_Dec(ElementDeclaration): + literal = "RefreshFirewall" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshFirewall") + kw["aname"] = "_RefreshFirewall" + if ns0.RefreshFirewallRequestType_Def not in ns0.RefreshFirewall_Dec.__bases__: + bases = list(ns0.RefreshFirewall_Dec.__bases__) + bases.insert(0, ns0.RefreshFirewallRequestType_Def) + ns0.RefreshFirewall_Dec.__bases__ = tuple(bases) + + ns0.RefreshFirewallRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshFirewall_Dec_Holder" + + class RefreshFirewallResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshFirewallResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshFirewallResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshFirewallResponse") + kw["aname"] = "_RefreshFirewallResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshFirewallResponse_Holder" + self.pyclass = Holder + + class ResetFirmwareToFactoryDefaults_Dec(ElementDeclaration): + literal = "ResetFirmwareToFactoryDefaults" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetFirmwareToFactoryDefaults") + kw["aname"] = "_ResetFirmwareToFactoryDefaults" + if ns0.ResetFirmwareToFactoryDefaultsRequestType_Def not in ns0.ResetFirmwareToFactoryDefaults_Dec.__bases__: + bases = list(ns0.ResetFirmwareToFactoryDefaults_Dec.__bases__) + bases.insert(0, ns0.ResetFirmwareToFactoryDefaultsRequestType_Def) + ns0.ResetFirmwareToFactoryDefaults_Dec.__bases__ = tuple(bases) + + ns0.ResetFirmwareToFactoryDefaultsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetFirmwareToFactoryDefaults_Dec_Holder" + + class ResetFirmwareToFactoryDefaultsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetFirmwareToFactoryDefaultsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetFirmwareToFactoryDefaultsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetFirmwareToFactoryDefaultsResponse") + kw["aname"] = "_ResetFirmwareToFactoryDefaultsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetFirmwareToFactoryDefaultsResponse_Holder" + self.pyclass = Holder + + class BackupFirmwareConfiguration_Dec(ElementDeclaration): + literal = "BackupFirmwareConfiguration" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","BackupFirmwareConfiguration") + kw["aname"] = "_BackupFirmwareConfiguration" + if ns0.BackupFirmwareConfigurationRequestType_Def not in ns0.BackupFirmwareConfiguration_Dec.__bases__: + bases = list(ns0.BackupFirmwareConfiguration_Dec.__bases__) + bases.insert(0, ns0.BackupFirmwareConfigurationRequestType_Def) + ns0.BackupFirmwareConfiguration_Dec.__bases__ = tuple(bases) + + ns0.BackupFirmwareConfigurationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "BackupFirmwareConfiguration_Dec_Holder" + + class BackupFirmwareConfigurationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "BackupFirmwareConfigurationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.BackupFirmwareConfigurationResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","BackupFirmwareConfigurationResponse") + kw["aname"] = "_BackupFirmwareConfigurationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "BackupFirmwareConfigurationResponse_Holder" + self.pyclass = Holder + + class QueryFirmwareConfigUploadURL_Dec(ElementDeclaration): + literal = "QueryFirmwareConfigUploadURL" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryFirmwareConfigUploadURL") + kw["aname"] = "_QueryFirmwareConfigUploadURL" + if ns0.QueryFirmwareConfigUploadURLRequestType_Def not in ns0.QueryFirmwareConfigUploadURL_Dec.__bases__: + bases = list(ns0.QueryFirmwareConfigUploadURL_Dec.__bases__) + bases.insert(0, ns0.QueryFirmwareConfigUploadURLRequestType_Def) + ns0.QueryFirmwareConfigUploadURL_Dec.__bases__ = tuple(bases) + + ns0.QueryFirmwareConfigUploadURLRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryFirmwareConfigUploadURL_Dec_Holder" + + class QueryFirmwareConfigUploadURLResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryFirmwareConfigUploadURLResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryFirmwareConfigUploadURLResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryFirmwareConfigUploadURLResponse") + kw["aname"] = "_QueryFirmwareConfigUploadURLResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryFirmwareConfigUploadURLResponse_Holder" + self.pyclass = Holder + + class RestoreFirmwareConfiguration_Dec(ElementDeclaration): + literal = "RestoreFirmwareConfiguration" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RestoreFirmwareConfiguration") + kw["aname"] = "_RestoreFirmwareConfiguration" + if ns0.RestoreFirmwareConfigurationRequestType_Def not in ns0.RestoreFirmwareConfiguration_Dec.__bases__: + bases = list(ns0.RestoreFirmwareConfiguration_Dec.__bases__) + bases.insert(0, ns0.RestoreFirmwareConfigurationRequestType_Def) + ns0.RestoreFirmwareConfiguration_Dec.__bases__ = tuple(bases) + + ns0.RestoreFirmwareConfigurationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RestoreFirmwareConfiguration_Dec_Holder" + + class RestoreFirmwareConfigurationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RestoreFirmwareConfigurationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RestoreFirmwareConfigurationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RestoreFirmwareConfigurationResponse") + kw["aname"] = "_RestoreFirmwareConfigurationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RestoreFirmwareConfigurationResponse_Holder" + self.pyclass = Holder + + class RefreshHealthStatusSystem_Dec(ElementDeclaration): + literal = "RefreshHealthStatusSystem" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshHealthStatusSystem") + kw["aname"] = "_RefreshHealthStatusSystem" + if ns0.RefreshHealthStatusSystemRequestType_Def not in ns0.RefreshHealthStatusSystem_Dec.__bases__: + bases = list(ns0.RefreshHealthStatusSystem_Dec.__bases__) + bases.insert(0, ns0.RefreshHealthStatusSystemRequestType_Def) + ns0.RefreshHealthStatusSystem_Dec.__bases__ = tuple(bases) + + ns0.RefreshHealthStatusSystemRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshHealthStatusSystem_Dec_Holder" + + class RefreshHealthStatusSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshHealthStatusSystemResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshHealthStatusSystemResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshHealthStatusSystemResponse") + kw["aname"] = "_RefreshHealthStatusSystemResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshHealthStatusSystemResponse_Holder" + self.pyclass = Holder + + class ResetSystemHealthInfo_Dec(ElementDeclaration): + literal = "ResetSystemHealthInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetSystemHealthInfo") + kw["aname"] = "_ResetSystemHealthInfo" + if ns0.ResetSystemHealthInfoRequestType_Def not in ns0.ResetSystemHealthInfo_Dec.__bases__: + bases = list(ns0.ResetSystemHealthInfo_Dec.__bases__) + bases.insert(0, ns0.ResetSystemHealthInfoRequestType_Def) + ns0.ResetSystemHealthInfo_Dec.__bases__ = tuple(bases) + + ns0.ResetSystemHealthInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetSystemHealthInfo_Dec_Holder" + + class ResetSystemHealthInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetSystemHealthInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetSystemHealthInfoResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetSystemHealthInfoResponse") + kw["aname"] = "_ResetSystemHealthInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetSystemHealthInfoResponse_Holder" + self.pyclass = Holder + + class QueryModules_Dec(ElementDeclaration): + literal = "QueryModules" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryModules") + kw["aname"] = "_QueryModules" + if ns0.QueryModulesRequestType_Def not in ns0.QueryModules_Dec.__bases__: + bases = list(ns0.QueryModules_Dec.__bases__) + bases.insert(0, ns0.QueryModulesRequestType_Def) + ns0.QueryModules_Dec.__bases__ = tuple(bases) + + ns0.QueryModulesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryModules_Dec_Holder" + + class QueryModulesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryModulesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryModulesResponse_Dec.schema + TClist = [GTD("urn:vim25","KernelModuleInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryModulesResponse") + kw["aname"] = "_QueryModulesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryModulesResponse_Holder" + self.pyclass = Holder + + class UpdateModuleOptionString_Dec(ElementDeclaration): + literal = "UpdateModuleOptionString" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateModuleOptionString") + kw["aname"] = "_UpdateModuleOptionString" + if ns0.UpdateModuleOptionStringRequestType_Def not in ns0.UpdateModuleOptionString_Dec.__bases__: + bases = list(ns0.UpdateModuleOptionString_Dec.__bases__) + bases.insert(0, ns0.UpdateModuleOptionStringRequestType_Def) + ns0.UpdateModuleOptionString_Dec.__bases__ = tuple(bases) + + ns0.UpdateModuleOptionStringRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateModuleOptionString_Dec_Holder" + + class UpdateModuleOptionStringResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateModuleOptionStringResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateModuleOptionStringResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateModuleOptionStringResponse") + kw["aname"] = "_UpdateModuleOptionStringResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateModuleOptionStringResponse_Holder" + self.pyclass = Holder + + class QueryConfiguredModuleOptionString_Dec(ElementDeclaration): + literal = "QueryConfiguredModuleOptionString" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryConfiguredModuleOptionString") + kw["aname"] = "_QueryConfiguredModuleOptionString" + if ns0.QueryConfiguredModuleOptionStringRequestType_Def not in ns0.QueryConfiguredModuleOptionString_Dec.__bases__: + bases = list(ns0.QueryConfiguredModuleOptionString_Dec.__bases__) + bases.insert(0, ns0.QueryConfiguredModuleOptionStringRequestType_Def) + ns0.QueryConfiguredModuleOptionString_Dec.__bases__ = tuple(bases) + + ns0.QueryConfiguredModuleOptionStringRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryConfiguredModuleOptionString_Dec_Holder" + + class QueryConfiguredModuleOptionStringResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryConfiguredModuleOptionStringResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryConfiguredModuleOptionStringResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryConfiguredModuleOptionStringResponse") + kw["aname"] = "_QueryConfiguredModuleOptionStringResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryConfiguredModuleOptionStringResponse_Holder" + self.pyclass = Holder + + class CreateUser_Dec(ElementDeclaration): + literal = "CreateUser" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateUser") + kw["aname"] = "_CreateUser" + if ns0.CreateUserRequestType_Def not in ns0.CreateUser_Dec.__bases__: + bases = list(ns0.CreateUser_Dec.__bases__) + bases.insert(0, ns0.CreateUserRequestType_Def) + ns0.CreateUser_Dec.__bases__ = tuple(bases) + + ns0.CreateUserRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateUser_Dec_Holder" + + class CreateUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateUserResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateUserResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CreateUserResponse") + kw["aname"] = "_CreateUserResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CreateUserResponse_Holder" + self.pyclass = Holder + + class UpdateUser_Dec(ElementDeclaration): + literal = "UpdateUser" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateUser") + kw["aname"] = "_UpdateUser" + if ns0.UpdateUserRequestType_Def not in ns0.UpdateUser_Dec.__bases__: + bases = list(ns0.UpdateUser_Dec.__bases__) + bases.insert(0, ns0.UpdateUserRequestType_Def) + ns0.UpdateUser_Dec.__bases__ = tuple(bases) + + ns0.UpdateUserRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateUser_Dec_Holder" + + class UpdateUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateUserResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateUserResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateUserResponse") + kw["aname"] = "_UpdateUserResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateUserResponse_Holder" + self.pyclass = Holder + + class CreateGroup_Dec(ElementDeclaration): + literal = "CreateGroup" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateGroup") + kw["aname"] = "_CreateGroup" + if ns0.CreateGroupRequestType_Def not in ns0.CreateGroup_Dec.__bases__: + bases = list(ns0.CreateGroup_Dec.__bases__) + bases.insert(0, ns0.CreateGroupRequestType_Def) + ns0.CreateGroup_Dec.__bases__ = tuple(bases) + + ns0.CreateGroupRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateGroup_Dec_Holder" + + class CreateGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateGroupResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateGroupResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","CreateGroupResponse") + kw["aname"] = "_CreateGroupResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "CreateGroupResponse_Holder" + self.pyclass = Holder + + class RemoveUser_Dec(ElementDeclaration): + literal = "RemoveUser" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveUser") + kw["aname"] = "_RemoveUser" + if ns0.RemoveUserRequestType_Def not in ns0.RemoveUser_Dec.__bases__: + bases = list(ns0.RemoveUser_Dec.__bases__) + bases.insert(0, ns0.RemoveUserRequestType_Def) + ns0.RemoveUser_Dec.__bases__ = tuple(bases) + + ns0.RemoveUserRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveUser_Dec_Holder" + + class RemoveUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveUserResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveUserResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveUserResponse") + kw["aname"] = "_RemoveUserResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveUserResponse_Holder" + self.pyclass = Holder + + class RemoveGroup_Dec(ElementDeclaration): + literal = "RemoveGroup" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveGroup") + kw["aname"] = "_RemoveGroup" + if ns0.RemoveGroupRequestType_Def not in ns0.RemoveGroup_Dec.__bases__: + bases = list(ns0.RemoveGroup_Dec.__bases__) + bases.insert(0, ns0.RemoveGroupRequestType_Def) + ns0.RemoveGroup_Dec.__bases__ = tuple(bases) + + ns0.RemoveGroupRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveGroup_Dec_Holder" + + class RemoveGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveGroupResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveGroupResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveGroupResponse") + kw["aname"] = "_RemoveGroupResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveGroupResponse_Holder" + self.pyclass = Holder + + class AssignUserToGroup_Dec(ElementDeclaration): + literal = "AssignUserToGroup" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AssignUserToGroup") + kw["aname"] = "_AssignUserToGroup" + if ns0.AssignUserToGroupRequestType_Def not in ns0.AssignUserToGroup_Dec.__bases__: + bases = list(ns0.AssignUserToGroup_Dec.__bases__) + bases.insert(0, ns0.AssignUserToGroupRequestType_Def) + ns0.AssignUserToGroup_Dec.__bases__ = tuple(bases) + + ns0.AssignUserToGroupRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AssignUserToGroup_Dec_Holder" + + class AssignUserToGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AssignUserToGroupResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AssignUserToGroupResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AssignUserToGroupResponse") + kw["aname"] = "_AssignUserToGroupResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AssignUserToGroupResponse_Holder" + self.pyclass = Holder + + class UnassignUserFromGroup_Dec(ElementDeclaration): + literal = "UnassignUserFromGroup" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnassignUserFromGroup") + kw["aname"] = "_UnassignUserFromGroup" + if ns0.UnassignUserFromGroupRequestType_Def not in ns0.UnassignUserFromGroup_Dec.__bases__: + bases = list(ns0.UnassignUserFromGroup_Dec.__bases__) + bases.insert(0, ns0.UnassignUserFromGroupRequestType_Def) + ns0.UnassignUserFromGroup_Dec.__bases__ = tuple(bases) + + ns0.UnassignUserFromGroupRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnassignUserFromGroup_Dec_Holder" + + class UnassignUserFromGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UnassignUserFromGroupResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UnassignUserFromGroupResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UnassignUserFromGroupResponse") + kw["aname"] = "_UnassignUserFromGroupResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UnassignUserFromGroupResponse_Holder" + self.pyclass = Holder + + class ReconfigureServiceConsoleReservation_Dec(ElementDeclaration): + literal = "ReconfigureServiceConsoleReservation" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureServiceConsoleReservation") + kw["aname"] = "_ReconfigureServiceConsoleReservation" + if ns0.ReconfigureServiceConsoleReservationRequestType_Def not in ns0.ReconfigureServiceConsoleReservation_Dec.__bases__: + bases = list(ns0.ReconfigureServiceConsoleReservation_Dec.__bases__) + bases.insert(0, ns0.ReconfigureServiceConsoleReservationRequestType_Def) + ns0.ReconfigureServiceConsoleReservation_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureServiceConsoleReservationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureServiceConsoleReservation_Dec_Holder" + + class ReconfigureServiceConsoleReservationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureServiceConsoleReservationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureServiceConsoleReservationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureServiceConsoleReservationResponse") + kw["aname"] = "_ReconfigureServiceConsoleReservationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureServiceConsoleReservationResponse_Holder" + self.pyclass = Holder + + class ReconfigureVirtualMachineReservation_Dec(ElementDeclaration): + literal = "ReconfigureVirtualMachineReservation" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureVirtualMachineReservation") + kw["aname"] = "_ReconfigureVirtualMachineReservation" + if ns0.ReconfigureVirtualMachineReservationRequestType_Def not in ns0.ReconfigureVirtualMachineReservation_Dec.__bases__: + bases = list(ns0.ReconfigureVirtualMachineReservation_Dec.__bases__) + bases.insert(0, ns0.ReconfigureVirtualMachineReservationRequestType_Def) + ns0.ReconfigureVirtualMachineReservation_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureVirtualMachineReservationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureVirtualMachineReservation_Dec_Holder" + + class ReconfigureVirtualMachineReservationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureVirtualMachineReservationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureVirtualMachineReservationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureVirtualMachineReservationResponse") + kw["aname"] = "_ReconfigureVirtualMachineReservationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureVirtualMachineReservationResponse_Holder" + self.pyclass = Holder + + class UpdateNetworkConfig_Dec(ElementDeclaration): + literal = "UpdateNetworkConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateNetworkConfig") + kw["aname"] = "_UpdateNetworkConfig" + if ns0.UpdateNetworkConfigRequestType_Def not in ns0.UpdateNetworkConfig_Dec.__bases__: + bases = list(ns0.UpdateNetworkConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateNetworkConfigRequestType_Def) + ns0.UpdateNetworkConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateNetworkConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateNetworkConfig_Dec_Holder" + + class UpdateNetworkConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateNetworkConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateNetworkConfigResponse_Dec.schema + TClist = [GTD("urn:vim25","HostNetworkConfigResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UpdateNetworkConfigResponse") + kw["aname"] = "_UpdateNetworkConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UpdateNetworkConfigResponse_Holder" + self.pyclass = Holder + + class UpdateDnsConfig_Dec(ElementDeclaration): + literal = "UpdateDnsConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateDnsConfig") + kw["aname"] = "_UpdateDnsConfig" + if ns0.UpdateDnsConfigRequestType_Def not in ns0.UpdateDnsConfig_Dec.__bases__: + bases = list(ns0.UpdateDnsConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateDnsConfigRequestType_Def) + ns0.UpdateDnsConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateDnsConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateDnsConfig_Dec_Holder" + + class UpdateDnsConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateDnsConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateDnsConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateDnsConfigResponse") + kw["aname"] = "_UpdateDnsConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateDnsConfigResponse_Holder" + self.pyclass = Holder + + class UpdateIpRouteConfig_Dec(ElementDeclaration): + literal = "UpdateIpRouteConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateIpRouteConfig") + kw["aname"] = "_UpdateIpRouteConfig" + if ns0.UpdateIpRouteConfigRequestType_Def not in ns0.UpdateIpRouteConfig_Dec.__bases__: + bases = list(ns0.UpdateIpRouteConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateIpRouteConfigRequestType_Def) + ns0.UpdateIpRouteConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateIpRouteConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpRouteConfig_Dec_Holder" + + class UpdateIpRouteConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateIpRouteConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateIpRouteConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateIpRouteConfigResponse") + kw["aname"] = "_UpdateIpRouteConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateIpRouteConfigResponse_Holder" + self.pyclass = Holder + + class UpdateConsoleIpRouteConfig_Dec(ElementDeclaration): + literal = "UpdateConsoleIpRouteConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateConsoleIpRouteConfig") + kw["aname"] = "_UpdateConsoleIpRouteConfig" + if ns0.UpdateConsoleIpRouteConfigRequestType_Def not in ns0.UpdateConsoleIpRouteConfig_Dec.__bases__: + bases = list(ns0.UpdateConsoleIpRouteConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateConsoleIpRouteConfigRequestType_Def) + ns0.UpdateConsoleIpRouteConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateConsoleIpRouteConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateConsoleIpRouteConfig_Dec_Holder" + + class UpdateConsoleIpRouteConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateConsoleIpRouteConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateConsoleIpRouteConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateConsoleIpRouteConfigResponse") + kw["aname"] = "_UpdateConsoleIpRouteConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateConsoleIpRouteConfigResponse_Holder" + self.pyclass = Holder + + class UpdateIpRouteTableConfig_Dec(ElementDeclaration): + literal = "UpdateIpRouteTableConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateIpRouteTableConfig") + kw["aname"] = "_UpdateIpRouteTableConfig" + if ns0.UpdateIpRouteTableConfigRequestType_Def not in ns0.UpdateIpRouteTableConfig_Dec.__bases__: + bases = list(ns0.UpdateIpRouteTableConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateIpRouteTableConfigRequestType_Def) + ns0.UpdateIpRouteTableConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateIpRouteTableConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpRouteTableConfig_Dec_Holder" + + class UpdateIpRouteTableConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateIpRouteTableConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateIpRouteTableConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateIpRouteTableConfigResponse") + kw["aname"] = "_UpdateIpRouteTableConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateIpRouteTableConfigResponse_Holder" + self.pyclass = Holder + + class AddVirtualSwitch_Dec(ElementDeclaration): + literal = "AddVirtualSwitch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddVirtualSwitch") + kw["aname"] = "_AddVirtualSwitch" + if ns0.AddVirtualSwitchRequestType_Def not in ns0.AddVirtualSwitch_Dec.__bases__: + bases = list(ns0.AddVirtualSwitch_Dec.__bases__) + bases.insert(0, ns0.AddVirtualSwitchRequestType_Def) + ns0.AddVirtualSwitch_Dec.__bases__ = tuple(bases) + + ns0.AddVirtualSwitchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddVirtualSwitch_Dec_Holder" + + class AddVirtualSwitchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddVirtualSwitchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddVirtualSwitchResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AddVirtualSwitchResponse") + kw["aname"] = "_AddVirtualSwitchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AddVirtualSwitchResponse_Holder" + self.pyclass = Holder + + class RemoveVirtualSwitch_Dec(ElementDeclaration): + literal = "RemoveVirtualSwitch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveVirtualSwitch") + kw["aname"] = "_RemoveVirtualSwitch" + if ns0.RemoveVirtualSwitchRequestType_Def not in ns0.RemoveVirtualSwitch_Dec.__bases__: + bases = list(ns0.RemoveVirtualSwitch_Dec.__bases__) + bases.insert(0, ns0.RemoveVirtualSwitchRequestType_Def) + ns0.RemoveVirtualSwitch_Dec.__bases__ = tuple(bases) + + ns0.RemoveVirtualSwitchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveVirtualSwitch_Dec_Holder" + + class RemoveVirtualSwitchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveVirtualSwitchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveVirtualSwitchResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveVirtualSwitchResponse") + kw["aname"] = "_RemoveVirtualSwitchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveVirtualSwitchResponse_Holder" + self.pyclass = Holder + + class UpdateVirtualSwitch_Dec(ElementDeclaration): + literal = "UpdateVirtualSwitch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateVirtualSwitch") + kw["aname"] = "_UpdateVirtualSwitch" + if ns0.UpdateVirtualSwitchRequestType_Def not in ns0.UpdateVirtualSwitch_Dec.__bases__: + bases = list(ns0.UpdateVirtualSwitch_Dec.__bases__) + bases.insert(0, ns0.UpdateVirtualSwitchRequestType_Def) + ns0.UpdateVirtualSwitch_Dec.__bases__ = tuple(bases) + + ns0.UpdateVirtualSwitchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateVirtualSwitch_Dec_Holder" + + class UpdateVirtualSwitchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateVirtualSwitchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateVirtualSwitchResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateVirtualSwitchResponse") + kw["aname"] = "_UpdateVirtualSwitchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateVirtualSwitchResponse_Holder" + self.pyclass = Holder + + class AddPortGroup_Dec(ElementDeclaration): + literal = "AddPortGroup" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddPortGroup") + kw["aname"] = "_AddPortGroup" + if ns0.AddPortGroupRequestType_Def not in ns0.AddPortGroup_Dec.__bases__: + bases = list(ns0.AddPortGroup_Dec.__bases__) + bases.insert(0, ns0.AddPortGroupRequestType_Def) + ns0.AddPortGroup_Dec.__bases__ = tuple(bases) + + ns0.AddPortGroupRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddPortGroup_Dec_Holder" + + class AddPortGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddPortGroupResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddPortGroupResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AddPortGroupResponse") + kw["aname"] = "_AddPortGroupResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AddPortGroupResponse_Holder" + self.pyclass = Holder + + class RemovePortGroup_Dec(ElementDeclaration): + literal = "RemovePortGroup" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemovePortGroup") + kw["aname"] = "_RemovePortGroup" + if ns0.RemovePortGroupRequestType_Def not in ns0.RemovePortGroup_Dec.__bases__: + bases = list(ns0.RemovePortGroup_Dec.__bases__) + bases.insert(0, ns0.RemovePortGroupRequestType_Def) + ns0.RemovePortGroup_Dec.__bases__ = tuple(bases) + + ns0.RemovePortGroupRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemovePortGroup_Dec_Holder" + + class RemovePortGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemovePortGroupResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemovePortGroupResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemovePortGroupResponse") + kw["aname"] = "_RemovePortGroupResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemovePortGroupResponse_Holder" + self.pyclass = Holder + + class UpdatePortGroup_Dec(ElementDeclaration): + literal = "UpdatePortGroup" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdatePortGroup") + kw["aname"] = "_UpdatePortGroup" + if ns0.UpdatePortGroupRequestType_Def not in ns0.UpdatePortGroup_Dec.__bases__: + bases = list(ns0.UpdatePortGroup_Dec.__bases__) + bases.insert(0, ns0.UpdatePortGroupRequestType_Def) + ns0.UpdatePortGroup_Dec.__bases__ = tuple(bases) + + ns0.UpdatePortGroupRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdatePortGroup_Dec_Holder" + + class UpdatePortGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdatePortGroupResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdatePortGroupResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdatePortGroupResponse") + kw["aname"] = "_UpdatePortGroupResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdatePortGroupResponse_Holder" + self.pyclass = Holder + + class UpdatePhysicalNicLinkSpeed_Dec(ElementDeclaration): + literal = "UpdatePhysicalNicLinkSpeed" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdatePhysicalNicLinkSpeed") + kw["aname"] = "_UpdatePhysicalNicLinkSpeed" + if ns0.UpdatePhysicalNicLinkSpeedRequestType_Def not in ns0.UpdatePhysicalNicLinkSpeed_Dec.__bases__: + bases = list(ns0.UpdatePhysicalNicLinkSpeed_Dec.__bases__) + bases.insert(0, ns0.UpdatePhysicalNicLinkSpeedRequestType_Def) + ns0.UpdatePhysicalNicLinkSpeed_Dec.__bases__ = tuple(bases) + + ns0.UpdatePhysicalNicLinkSpeedRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdatePhysicalNicLinkSpeed_Dec_Holder" + + class UpdatePhysicalNicLinkSpeedResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdatePhysicalNicLinkSpeedResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdatePhysicalNicLinkSpeedResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdatePhysicalNicLinkSpeedResponse") + kw["aname"] = "_UpdatePhysicalNicLinkSpeedResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdatePhysicalNicLinkSpeedResponse_Holder" + self.pyclass = Holder + + class QueryNetworkHint_Dec(ElementDeclaration): + literal = "QueryNetworkHint" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryNetworkHint") + kw["aname"] = "_QueryNetworkHint" + if ns0.QueryNetworkHintRequestType_Def not in ns0.QueryNetworkHint_Dec.__bases__: + bases = list(ns0.QueryNetworkHint_Dec.__bases__) + bases.insert(0, ns0.QueryNetworkHintRequestType_Def) + ns0.QueryNetworkHint_Dec.__bases__ = tuple(bases) + + ns0.QueryNetworkHintRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryNetworkHint_Dec_Holder" + + class QueryNetworkHintResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryNetworkHintResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryNetworkHintResponse_Dec.schema + TClist = [GTD("urn:vim25","PhysicalNicHintInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryNetworkHintResponse") + kw["aname"] = "_QueryNetworkHintResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryNetworkHintResponse_Holder" + self.pyclass = Holder + + class AddVirtualNic_Dec(ElementDeclaration): + literal = "AddVirtualNic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddVirtualNic") + kw["aname"] = "_AddVirtualNic" + if ns0.AddVirtualNicRequestType_Def not in ns0.AddVirtualNic_Dec.__bases__: + bases = list(ns0.AddVirtualNic_Dec.__bases__) + bases.insert(0, ns0.AddVirtualNicRequestType_Def) + ns0.AddVirtualNic_Dec.__bases__ = tuple(bases) + + ns0.AddVirtualNicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddVirtualNic_Dec_Holder" + + class AddVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddVirtualNicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddVirtualNicResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddVirtualNicResponse") + kw["aname"] = "_AddVirtualNicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddVirtualNicResponse_Holder" + self.pyclass = Holder + + class RemoveVirtualNic_Dec(ElementDeclaration): + literal = "RemoveVirtualNic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveVirtualNic") + kw["aname"] = "_RemoveVirtualNic" + if ns0.RemoveVirtualNicRequestType_Def not in ns0.RemoveVirtualNic_Dec.__bases__: + bases = list(ns0.RemoveVirtualNic_Dec.__bases__) + bases.insert(0, ns0.RemoveVirtualNicRequestType_Def) + ns0.RemoveVirtualNic_Dec.__bases__ = tuple(bases) + + ns0.RemoveVirtualNicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveVirtualNic_Dec_Holder" + + class RemoveVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveVirtualNicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveVirtualNicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveVirtualNicResponse") + kw["aname"] = "_RemoveVirtualNicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveVirtualNicResponse_Holder" + self.pyclass = Holder + + class UpdateVirtualNic_Dec(ElementDeclaration): + literal = "UpdateVirtualNic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateVirtualNic") + kw["aname"] = "_UpdateVirtualNic" + if ns0.UpdateVirtualNicRequestType_Def not in ns0.UpdateVirtualNic_Dec.__bases__: + bases = list(ns0.UpdateVirtualNic_Dec.__bases__) + bases.insert(0, ns0.UpdateVirtualNicRequestType_Def) + ns0.UpdateVirtualNic_Dec.__bases__ = tuple(bases) + + ns0.UpdateVirtualNicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateVirtualNic_Dec_Holder" + + class UpdateVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateVirtualNicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateVirtualNicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateVirtualNicResponse") + kw["aname"] = "_UpdateVirtualNicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateVirtualNicResponse_Holder" + self.pyclass = Holder + + class AddServiceConsoleVirtualNic_Dec(ElementDeclaration): + literal = "AddServiceConsoleVirtualNic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddServiceConsoleVirtualNic") + kw["aname"] = "_AddServiceConsoleVirtualNic" + if ns0.AddServiceConsoleVirtualNicRequestType_Def not in ns0.AddServiceConsoleVirtualNic_Dec.__bases__: + bases = list(ns0.AddServiceConsoleVirtualNic_Dec.__bases__) + bases.insert(0, ns0.AddServiceConsoleVirtualNicRequestType_Def) + ns0.AddServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) + + ns0.AddServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddServiceConsoleVirtualNic_Dec_Holder" + + class AddServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddServiceConsoleVirtualNicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddServiceConsoleVirtualNicResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","AddServiceConsoleVirtualNicResponse") + kw["aname"] = "_AddServiceConsoleVirtualNicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "AddServiceConsoleVirtualNicResponse_Holder" + self.pyclass = Holder + + class RemoveServiceConsoleVirtualNic_Dec(ElementDeclaration): + literal = "RemoveServiceConsoleVirtualNic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveServiceConsoleVirtualNic") + kw["aname"] = "_RemoveServiceConsoleVirtualNic" + if ns0.RemoveServiceConsoleVirtualNicRequestType_Def not in ns0.RemoveServiceConsoleVirtualNic_Dec.__bases__: + bases = list(ns0.RemoveServiceConsoleVirtualNic_Dec.__bases__) + bases.insert(0, ns0.RemoveServiceConsoleVirtualNicRequestType_Def) + ns0.RemoveServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) + + ns0.RemoveServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveServiceConsoleVirtualNic_Dec_Holder" + + class RemoveServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveServiceConsoleVirtualNicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveServiceConsoleVirtualNicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveServiceConsoleVirtualNicResponse") + kw["aname"] = "_RemoveServiceConsoleVirtualNicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveServiceConsoleVirtualNicResponse_Holder" + self.pyclass = Holder + + class UpdateServiceConsoleVirtualNic_Dec(ElementDeclaration): + literal = "UpdateServiceConsoleVirtualNic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateServiceConsoleVirtualNic") + kw["aname"] = "_UpdateServiceConsoleVirtualNic" + if ns0.UpdateServiceConsoleVirtualNicRequestType_Def not in ns0.UpdateServiceConsoleVirtualNic_Dec.__bases__: + bases = list(ns0.UpdateServiceConsoleVirtualNic_Dec.__bases__) + bases.insert(0, ns0.UpdateServiceConsoleVirtualNicRequestType_Def) + ns0.UpdateServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) + + ns0.UpdateServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateServiceConsoleVirtualNic_Dec_Holder" + + class UpdateServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateServiceConsoleVirtualNicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateServiceConsoleVirtualNicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateServiceConsoleVirtualNicResponse") + kw["aname"] = "_UpdateServiceConsoleVirtualNicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateServiceConsoleVirtualNicResponse_Holder" + self.pyclass = Holder + + class RestartServiceConsoleVirtualNic_Dec(ElementDeclaration): + literal = "RestartServiceConsoleVirtualNic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RestartServiceConsoleVirtualNic") + kw["aname"] = "_RestartServiceConsoleVirtualNic" + if ns0.RestartServiceConsoleVirtualNicRequestType_Def not in ns0.RestartServiceConsoleVirtualNic_Dec.__bases__: + bases = list(ns0.RestartServiceConsoleVirtualNic_Dec.__bases__) + bases.insert(0, ns0.RestartServiceConsoleVirtualNicRequestType_Def) + ns0.RestartServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) + + ns0.RestartServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RestartServiceConsoleVirtualNic_Dec_Holder" + + class RestartServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RestartServiceConsoleVirtualNicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RestartServiceConsoleVirtualNicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RestartServiceConsoleVirtualNicResponse") + kw["aname"] = "_RestartServiceConsoleVirtualNicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RestartServiceConsoleVirtualNicResponse_Holder" + self.pyclass = Holder + + class RefreshNetworkSystem_Dec(ElementDeclaration): + literal = "RefreshNetworkSystem" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshNetworkSystem") + kw["aname"] = "_RefreshNetworkSystem" + if ns0.RefreshNetworkSystemRequestType_Def not in ns0.RefreshNetworkSystem_Dec.__bases__: + bases = list(ns0.RefreshNetworkSystem_Dec.__bases__) + bases.insert(0, ns0.RefreshNetworkSystemRequestType_Def) + ns0.RefreshNetworkSystem_Dec.__bases__ = tuple(bases) + + ns0.RefreshNetworkSystemRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshNetworkSystem_Dec_Holder" + + class RefreshNetworkSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshNetworkSystemResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshNetworkSystemResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshNetworkSystemResponse") + kw["aname"] = "_RefreshNetworkSystemResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshNetworkSystemResponse_Holder" + self.pyclass = Holder + + class CheckHostPatch_Dec(ElementDeclaration): + literal = "CheckHostPatch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckHostPatch") + kw["aname"] = "_CheckHostPatch" + if ns0.CheckHostPatchRequestType_Def not in ns0.CheckHostPatch_Dec.__bases__: + bases = list(ns0.CheckHostPatch_Dec.__bases__) + bases.insert(0, ns0.CheckHostPatchRequestType_Def) + ns0.CheckHostPatch_Dec.__bases__ = tuple(bases) + + ns0.CheckHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckHostPatch_Dec_Holder" + + class CheckHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckHostPatchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckHostPatchResponse_Dec.schema + TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckHostPatchResponse") + kw["aname"] = "_CheckHostPatchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CheckHostPatchResponse_Holder" + self.pyclass = Holder + + class CheckHostPatch_Task_Dec(ElementDeclaration): + literal = "CheckHostPatch_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckHostPatch_Task") + kw["aname"] = "_CheckHostPatch_Task" + if ns0.CheckHostPatchRequestType_Def not in ns0.CheckHostPatch_Task_Dec.__bases__: + bases = list(ns0.CheckHostPatch_Task_Dec.__bases__) + bases.insert(0, ns0.CheckHostPatchRequestType_Def) + ns0.CheckHostPatch_Task_Dec.__bases__ = tuple(bases) + + ns0.CheckHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckHostPatch_Task_Dec_Holder" + + class CheckHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckHostPatch_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckHostPatch_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckHostPatch_TaskResponse") + kw["aname"] = "_CheckHostPatch_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CheckHostPatch_TaskResponse_Holder" + self.pyclass = Holder + + class ScanHostPatch_Dec(ElementDeclaration): + literal = "ScanHostPatch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ScanHostPatch") + kw["aname"] = "_ScanHostPatch" + if ns0.ScanHostPatchRequestType_Def not in ns0.ScanHostPatch_Dec.__bases__: + bases = list(ns0.ScanHostPatch_Dec.__bases__) + bases.insert(0, ns0.ScanHostPatchRequestType_Def) + ns0.ScanHostPatch_Dec.__bases__ = tuple(bases) + + ns0.ScanHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatch_Dec_Holder" + + class ScanHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ScanHostPatchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ScanHostPatchResponse_Dec.schema + TClist = [GTD("urn:vim25","HostPatchManagerStatus",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ScanHostPatchResponse") + kw["aname"] = "_ScanHostPatchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ScanHostPatchResponse_Holder" + self.pyclass = Holder + + class ScanHostPatch_Task_Dec(ElementDeclaration): + literal = "ScanHostPatch_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ScanHostPatch_Task") + kw["aname"] = "_ScanHostPatch_Task" + if ns0.ScanHostPatchRequestType_Def not in ns0.ScanHostPatch_Task_Dec.__bases__: + bases = list(ns0.ScanHostPatch_Task_Dec.__bases__) + bases.insert(0, ns0.ScanHostPatchRequestType_Def) + ns0.ScanHostPatch_Task_Dec.__bases__ = tuple(bases) + + ns0.ScanHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatch_Task_Dec_Holder" + + class ScanHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ScanHostPatch_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ScanHostPatch_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ScanHostPatch_TaskResponse") + kw["aname"] = "_ScanHostPatch_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ScanHostPatch_TaskResponse_Holder" + self.pyclass = Holder + + class ScanHostPatchV2_Dec(ElementDeclaration): + literal = "ScanHostPatchV2" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ScanHostPatchV2") + kw["aname"] = "_ScanHostPatchV2" + if ns0.ScanHostPatchV2RequestType_Def not in ns0.ScanHostPatchV2_Dec.__bases__: + bases = list(ns0.ScanHostPatchV2_Dec.__bases__) + bases.insert(0, ns0.ScanHostPatchV2RequestType_Def) + ns0.ScanHostPatchV2_Dec.__bases__ = tuple(bases) + + ns0.ScanHostPatchV2RequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatchV2_Dec_Holder" + + class ScanHostPatchV2Response_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ScanHostPatchV2Response" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ScanHostPatchV2Response_Dec.schema + TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ScanHostPatchV2Response") + kw["aname"] = "_ScanHostPatchV2Response" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ScanHostPatchV2Response_Holder" + self.pyclass = Holder + + class ScanHostPatchV2_Task_Dec(ElementDeclaration): + literal = "ScanHostPatchV2_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ScanHostPatchV2_Task") + kw["aname"] = "_ScanHostPatchV2_Task" + if ns0.ScanHostPatchV2RequestType_Def not in ns0.ScanHostPatchV2_Task_Dec.__bases__: + bases = list(ns0.ScanHostPatchV2_Task_Dec.__bases__) + bases.insert(0, ns0.ScanHostPatchV2RequestType_Def) + ns0.ScanHostPatchV2_Task_Dec.__bases__ = tuple(bases) + + ns0.ScanHostPatchV2RequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatchV2_Task_Dec_Holder" + + class ScanHostPatchV2_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ScanHostPatchV2_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ScanHostPatchV2_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ScanHostPatchV2_TaskResponse") + kw["aname"] = "_ScanHostPatchV2_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ScanHostPatchV2_TaskResponse_Holder" + self.pyclass = Holder + + class StageHostPatch_Dec(ElementDeclaration): + literal = "StageHostPatch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StageHostPatch") + kw["aname"] = "_StageHostPatch" + if ns0.StageHostPatchRequestType_Def not in ns0.StageHostPatch_Dec.__bases__: + bases = list(ns0.StageHostPatch_Dec.__bases__) + bases.insert(0, ns0.StageHostPatchRequestType_Def) + ns0.StageHostPatch_Dec.__bases__ = tuple(bases) + + ns0.StageHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StageHostPatch_Dec_Holder" + + class StageHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StageHostPatchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StageHostPatchResponse_Dec.schema + TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","StageHostPatchResponse") + kw["aname"] = "_StageHostPatchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "StageHostPatchResponse_Holder" + self.pyclass = Holder + + class StageHostPatch_Task_Dec(ElementDeclaration): + literal = "StageHostPatch_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StageHostPatch_Task") + kw["aname"] = "_StageHostPatch_Task" + if ns0.StageHostPatchRequestType_Def not in ns0.StageHostPatch_Task_Dec.__bases__: + bases = list(ns0.StageHostPatch_Task_Dec.__bases__) + bases.insert(0, ns0.StageHostPatchRequestType_Def) + ns0.StageHostPatch_Task_Dec.__bases__ = tuple(bases) + + ns0.StageHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StageHostPatch_Task_Dec_Holder" + + class StageHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StageHostPatch_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StageHostPatch_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","StageHostPatch_TaskResponse") + kw["aname"] = "_StageHostPatch_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "StageHostPatch_TaskResponse_Holder" + self.pyclass = Holder + + class InstallHostPatch_Dec(ElementDeclaration): + literal = "InstallHostPatch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InstallHostPatch") + kw["aname"] = "_InstallHostPatch" + if ns0.InstallHostPatchRequestType_Def not in ns0.InstallHostPatch_Dec.__bases__: + bases = list(ns0.InstallHostPatch_Dec.__bases__) + bases.insert(0, ns0.InstallHostPatchRequestType_Def) + ns0.InstallHostPatch_Dec.__bases__ = tuple(bases) + + ns0.InstallHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatch_Dec_Holder" + + class InstallHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "InstallHostPatchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.InstallHostPatchResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","InstallHostPatchResponse") + kw["aname"] = "_InstallHostPatchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "InstallHostPatchResponse_Holder" + self.pyclass = Holder + + class InstallHostPatch_Task_Dec(ElementDeclaration): + literal = "InstallHostPatch_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InstallHostPatch_Task") + kw["aname"] = "_InstallHostPatch_Task" + if ns0.InstallHostPatchRequestType_Def not in ns0.InstallHostPatch_Task_Dec.__bases__: + bases = list(ns0.InstallHostPatch_Task_Dec.__bases__) + bases.insert(0, ns0.InstallHostPatchRequestType_Def) + ns0.InstallHostPatch_Task_Dec.__bases__ = tuple(bases) + + ns0.InstallHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatch_Task_Dec_Holder" + + class InstallHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "InstallHostPatch_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.InstallHostPatch_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","InstallHostPatch_TaskResponse") + kw["aname"] = "_InstallHostPatch_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "InstallHostPatch_TaskResponse_Holder" + self.pyclass = Holder + + class InstallHostPatchV2_Dec(ElementDeclaration): + literal = "InstallHostPatchV2" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InstallHostPatchV2") + kw["aname"] = "_InstallHostPatchV2" + if ns0.InstallHostPatchV2RequestType_Def not in ns0.InstallHostPatchV2_Dec.__bases__: + bases = list(ns0.InstallHostPatchV2_Dec.__bases__) + bases.insert(0, ns0.InstallHostPatchV2RequestType_Def) + ns0.InstallHostPatchV2_Dec.__bases__ = tuple(bases) + + ns0.InstallHostPatchV2RequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatchV2_Dec_Holder" + + class InstallHostPatchV2Response_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "InstallHostPatchV2Response" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.InstallHostPatchV2Response_Dec.schema + TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","InstallHostPatchV2Response") + kw["aname"] = "_InstallHostPatchV2Response" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "InstallHostPatchV2Response_Holder" + self.pyclass = Holder + + class InstallHostPatchV2_Task_Dec(ElementDeclaration): + literal = "InstallHostPatchV2_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","InstallHostPatchV2_Task") + kw["aname"] = "_InstallHostPatchV2_Task" + if ns0.InstallHostPatchV2RequestType_Def not in ns0.InstallHostPatchV2_Task_Dec.__bases__: + bases = list(ns0.InstallHostPatchV2_Task_Dec.__bases__) + bases.insert(0, ns0.InstallHostPatchV2RequestType_Def) + ns0.InstallHostPatchV2_Task_Dec.__bases__ = tuple(bases) + + ns0.InstallHostPatchV2RequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatchV2_Task_Dec_Holder" + + class InstallHostPatchV2_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "InstallHostPatchV2_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.InstallHostPatchV2_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","InstallHostPatchV2_TaskResponse") + kw["aname"] = "_InstallHostPatchV2_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "InstallHostPatchV2_TaskResponse_Holder" + self.pyclass = Holder + + class UninstallHostPatch_Dec(ElementDeclaration): + literal = "UninstallHostPatch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UninstallHostPatch") + kw["aname"] = "_UninstallHostPatch" + if ns0.UninstallHostPatchRequestType_Def not in ns0.UninstallHostPatch_Dec.__bases__: + bases = list(ns0.UninstallHostPatch_Dec.__bases__) + bases.insert(0, ns0.UninstallHostPatchRequestType_Def) + ns0.UninstallHostPatch_Dec.__bases__ = tuple(bases) + + ns0.UninstallHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UninstallHostPatch_Dec_Holder" + + class UninstallHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UninstallHostPatchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UninstallHostPatchResponse_Dec.schema + TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UninstallHostPatchResponse") + kw["aname"] = "_UninstallHostPatchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UninstallHostPatchResponse_Holder" + self.pyclass = Holder + + class UninstallHostPatch_Task_Dec(ElementDeclaration): + literal = "UninstallHostPatch_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UninstallHostPatch_Task") + kw["aname"] = "_UninstallHostPatch_Task" + if ns0.UninstallHostPatchRequestType_Def not in ns0.UninstallHostPatch_Task_Dec.__bases__: + bases = list(ns0.UninstallHostPatch_Task_Dec.__bases__) + bases.insert(0, ns0.UninstallHostPatchRequestType_Def) + ns0.UninstallHostPatch_Task_Dec.__bases__ = tuple(bases) + + ns0.UninstallHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UninstallHostPatch_Task_Dec_Holder" + + class UninstallHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UninstallHostPatch_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UninstallHostPatch_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","UninstallHostPatch_TaskResponse") + kw["aname"] = "_UninstallHostPatch_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "UninstallHostPatch_TaskResponse_Holder" + self.pyclass = Holder + + class QueryHostPatch_Dec(ElementDeclaration): + literal = "QueryHostPatch" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryHostPatch") + kw["aname"] = "_QueryHostPatch" + if ns0.QueryHostPatchRequestType_Def not in ns0.QueryHostPatch_Dec.__bases__: + bases = list(ns0.QueryHostPatch_Dec.__bases__) + bases.insert(0, ns0.QueryHostPatchRequestType_Def) + ns0.QueryHostPatch_Dec.__bases__ = tuple(bases) + + ns0.QueryHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryHostPatch_Dec_Holder" + + class QueryHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryHostPatchResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryHostPatchResponse_Dec.schema + TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryHostPatchResponse") + kw["aname"] = "_QueryHostPatchResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryHostPatchResponse_Holder" + self.pyclass = Holder + + class QueryHostPatch_Task_Dec(ElementDeclaration): + literal = "QueryHostPatch_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryHostPatch_Task") + kw["aname"] = "_QueryHostPatch_Task" + if ns0.QueryHostPatchRequestType_Def not in ns0.QueryHostPatch_Task_Dec.__bases__: + bases = list(ns0.QueryHostPatch_Task_Dec.__bases__) + bases.insert(0, ns0.QueryHostPatchRequestType_Def) + ns0.QueryHostPatch_Task_Dec.__bases__ = tuple(bases) + + ns0.QueryHostPatchRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryHostPatch_Task_Dec_Holder" + + class QueryHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryHostPatch_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryHostPatch_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryHostPatch_TaskResponse") + kw["aname"] = "_QueryHostPatch_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryHostPatch_TaskResponse_Holder" + self.pyclass = Holder + + class Refresh_Dec(ElementDeclaration): + literal = "Refresh" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","Refresh") + kw["aname"] = "_Refresh" + if ns0.RefreshRequestType_Def not in ns0.Refresh_Dec.__bases__: + bases = list(ns0.Refresh_Dec.__bases__) + bases.insert(0, ns0.RefreshRequestType_Def) + ns0.Refresh_Dec.__bases__ = tuple(bases) + + ns0.RefreshRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "Refresh_Dec_Holder" + + class RefreshResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshResponse") + kw["aname"] = "_RefreshResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshResponse_Holder" + self.pyclass = Holder + + class UpdatePassthruConfig_Dec(ElementDeclaration): + literal = "UpdatePassthruConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdatePassthruConfig") + kw["aname"] = "_UpdatePassthruConfig" + if ns0.UpdatePassthruConfigRequestType_Def not in ns0.UpdatePassthruConfig_Dec.__bases__: + bases = list(ns0.UpdatePassthruConfig_Dec.__bases__) + bases.insert(0, ns0.UpdatePassthruConfigRequestType_Def) + ns0.UpdatePassthruConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdatePassthruConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdatePassthruConfig_Dec_Holder" + + class UpdatePassthruConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdatePassthruConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdatePassthruConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdatePassthruConfigResponse") + kw["aname"] = "_UpdatePassthruConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdatePassthruConfigResponse_Holder" + self.pyclass = Holder + + class UpdateServicePolicy_Dec(ElementDeclaration): + literal = "UpdateServicePolicy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateServicePolicy") + kw["aname"] = "_UpdateServicePolicy" + if ns0.UpdateServicePolicyRequestType_Def not in ns0.UpdateServicePolicy_Dec.__bases__: + bases = list(ns0.UpdateServicePolicy_Dec.__bases__) + bases.insert(0, ns0.UpdateServicePolicyRequestType_Def) + ns0.UpdateServicePolicy_Dec.__bases__ = tuple(bases) + + ns0.UpdateServicePolicyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateServicePolicy_Dec_Holder" + + class UpdateServicePolicyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateServicePolicyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateServicePolicyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateServicePolicyResponse") + kw["aname"] = "_UpdateServicePolicyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateServicePolicyResponse_Holder" + self.pyclass = Holder + + class StartService_Dec(ElementDeclaration): + literal = "StartService" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StartService") + kw["aname"] = "_StartService" + if ns0.StartServiceRequestType_Def not in ns0.StartService_Dec.__bases__: + bases = list(ns0.StartService_Dec.__bases__) + bases.insert(0, ns0.StartServiceRequestType_Def) + ns0.StartService_Dec.__bases__ = tuple(bases) + + ns0.StartServiceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StartService_Dec_Holder" + + class StartServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StartServiceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StartServiceResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","StartServiceResponse") + kw["aname"] = "_StartServiceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "StartServiceResponse_Holder" + self.pyclass = Holder + + class StopService_Dec(ElementDeclaration): + literal = "StopService" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","StopService") + kw["aname"] = "_StopService" + if ns0.StopServiceRequestType_Def not in ns0.StopService_Dec.__bases__: + bases = list(ns0.StopService_Dec.__bases__) + bases.insert(0, ns0.StopServiceRequestType_Def) + ns0.StopService_Dec.__bases__ = tuple(bases) + + ns0.StopServiceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "StopService_Dec_Holder" + + class StopServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "StopServiceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.StopServiceResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","StopServiceResponse") + kw["aname"] = "_StopServiceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "StopServiceResponse_Holder" + self.pyclass = Holder + + class RestartService_Dec(ElementDeclaration): + literal = "RestartService" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RestartService") + kw["aname"] = "_RestartService" + if ns0.RestartServiceRequestType_Def not in ns0.RestartService_Dec.__bases__: + bases = list(ns0.RestartService_Dec.__bases__) + bases.insert(0, ns0.RestartServiceRequestType_Def) + ns0.RestartService_Dec.__bases__ = tuple(bases) + + ns0.RestartServiceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RestartService_Dec_Holder" + + class RestartServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RestartServiceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RestartServiceResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RestartServiceResponse") + kw["aname"] = "_RestartServiceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RestartServiceResponse_Holder" + self.pyclass = Holder + + class UninstallService_Dec(ElementDeclaration): + literal = "UninstallService" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UninstallService") + kw["aname"] = "_UninstallService" + if ns0.UninstallServiceRequestType_Def not in ns0.UninstallService_Dec.__bases__: + bases = list(ns0.UninstallService_Dec.__bases__) + bases.insert(0, ns0.UninstallServiceRequestType_Def) + ns0.UninstallService_Dec.__bases__ = tuple(bases) + + ns0.UninstallServiceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UninstallService_Dec_Holder" + + class UninstallServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UninstallServiceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UninstallServiceResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UninstallServiceResponse") + kw["aname"] = "_UninstallServiceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UninstallServiceResponse_Holder" + self.pyclass = Holder + + class RefreshServices_Dec(ElementDeclaration): + literal = "RefreshServices" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshServices") + kw["aname"] = "_RefreshServices" + if ns0.RefreshServicesRequestType_Def not in ns0.RefreshServices_Dec.__bases__: + bases = list(ns0.RefreshServices_Dec.__bases__) + bases.insert(0, ns0.RefreshServicesRequestType_Def) + ns0.RefreshServices_Dec.__bases__ = tuple(bases) + + ns0.RefreshServicesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshServices_Dec_Holder" + + class RefreshServicesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshServicesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshServicesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshServicesResponse") + kw["aname"] = "_RefreshServicesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshServicesResponse_Holder" + self.pyclass = Holder + + class ReconfigureSnmpAgent_Dec(ElementDeclaration): + literal = "ReconfigureSnmpAgent" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureSnmpAgent") + kw["aname"] = "_ReconfigureSnmpAgent" + if ns0.ReconfigureSnmpAgentRequestType_Def not in ns0.ReconfigureSnmpAgent_Dec.__bases__: + bases = list(ns0.ReconfigureSnmpAgent_Dec.__bases__) + bases.insert(0, ns0.ReconfigureSnmpAgentRequestType_Def) + ns0.ReconfigureSnmpAgent_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureSnmpAgentRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureSnmpAgent_Dec_Holder" + + class ReconfigureSnmpAgentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureSnmpAgentResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureSnmpAgentResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureSnmpAgentResponse") + kw["aname"] = "_ReconfigureSnmpAgentResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureSnmpAgentResponse_Holder" + self.pyclass = Holder + + class SendTestNotification_Dec(ElementDeclaration): + literal = "SendTestNotification" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SendTestNotification") + kw["aname"] = "_SendTestNotification" + if ns0.SendTestNotificationRequestType_Def not in ns0.SendTestNotification_Dec.__bases__: + bases = list(ns0.SendTestNotification_Dec.__bases__) + bases.insert(0, ns0.SendTestNotificationRequestType_Def) + ns0.SendTestNotification_Dec.__bases__ = tuple(bases) + + ns0.SendTestNotificationRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SendTestNotification_Dec_Holder" + + class SendTestNotificationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SendTestNotificationResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SendTestNotificationResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SendTestNotificationResponse") + kw["aname"] = "_SendTestNotificationResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SendTestNotificationResponse_Holder" + self.pyclass = Holder + + class RetrieveDiskPartitionInfo_Dec(ElementDeclaration): + literal = "RetrieveDiskPartitionInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveDiskPartitionInfo") + kw["aname"] = "_RetrieveDiskPartitionInfo" + if ns0.RetrieveDiskPartitionInfoRequestType_Def not in ns0.RetrieveDiskPartitionInfo_Dec.__bases__: + bases = list(ns0.RetrieveDiskPartitionInfo_Dec.__bases__) + bases.insert(0, ns0.RetrieveDiskPartitionInfoRequestType_Def) + ns0.RetrieveDiskPartitionInfo_Dec.__bases__ = tuple(bases) + + ns0.RetrieveDiskPartitionInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveDiskPartitionInfo_Dec_Holder" + + class RetrieveDiskPartitionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveDiskPartitionInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveDiskPartitionInfoResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveDiskPartitionInfoResponse") + kw["aname"] = "_RetrieveDiskPartitionInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveDiskPartitionInfoResponse_Holder" + self.pyclass = Holder + + class ComputeDiskPartitionInfo_Dec(ElementDeclaration): + literal = "ComputeDiskPartitionInfo" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfo") + kw["aname"] = "_ComputeDiskPartitionInfo" + if ns0.ComputeDiskPartitionInfoRequestType_Def not in ns0.ComputeDiskPartitionInfo_Dec.__bases__: + bases = list(ns0.ComputeDiskPartitionInfo_Dec.__bases__) + bases.insert(0, ns0.ComputeDiskPartitionInfoRequestType_Def) + ns0.ComputeDiskPartitionInfo_Dec.__bases__ = tuple(bases) + + ns0.ComputeDiskPartitionInfoRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ComputeDiskPartitionInfo_Dec_Holder" + + class ComputeDiskPartitionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ComputeDiskPartitionInfoResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ComputeDiskPartitionInfoResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfoResponse") + kw["aname"] = "_ComputeDiskPartitionInfoResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ComputeDiskPartitionInfoResponse_Holder" + self.pyclass = Holder + + class ComputeDiskPartitionInfoForResize_Dec(ElementDeclaration): + literal = "ComputeDiskPartitionInfoForResize" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfoForResize") + kw["aname"] = "_ComputeDiskPartitionInfoForResize" + if ns0.ComputeDiskPartitionInfoForResizeRequestType_Def not in ns0.ComputeDiskPartitionInfoForResize_Dec.__bases__: + bases = list(ns0.ComputeDiskPartitionInfoForResize_Dec.__bases__) + bases.insert(0, ns0.ComputeDiskPartitionInfoForResizeRequestType_Def) + ns0.ComputeDiskPartitionInfoForResize_Dec.__bases__ = tuple(bases) + + ns0.ComputeDiskPartitionInfoForResizeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ComputeDiskPartitionInfoForResize_Dec_Holder" + + class ComputeDiskPartitionInfoForResizeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ComputeDiskPartitionInfoForResizeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ComputeDiskPartitionInfoForResizeResponse_Dec.schema + TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfoForResizeResponse") + kw["aname"] = "_ComputeDiskPartitionInfoForResizeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ComputeDiskPartitionInfoForResizeResponse_Holder" + self.pyclass = Holder + + class UpdateDiskPartitions_Dec(ElementDeclaration): + literal = "UpdateDiskPartitions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateDiskPartitions") + kw["aname"] = "_UpdateDiskPartitions" + if ns0.UpdateDiskPartitionsRequestType_Def not in ns0.UpdateDiskPartitions_Dec.__bases__: + bases = list(ns0.UpdateDiskPartitions_Dec.__bases__) + bases.insert(0, ns0.UpdateDiskPartitionsRequestType_Def) + ns0.UpdateDiskPartitions_Dec.__bases__ = tuple(bases) + + ns0.UpdateDiskPartitionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateDiskPartitions_Dec_Holder" + + class UpdateDiskPartitionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateDiskPartitionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateDiskPartitionsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateDiskPartitionsResponse") + kw["aname"] = "_UpdateDiskPartitionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateDiskPartitionsResponse_Holder" + self.pyclass = Holder + + class FormatVmfs_Dec(ElementDeclaration): + literal = "FormatVmfs" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","FormatVmfs") + kw["aname"] = "_FormatVmfs" + if ns0.FormatVmfsRequestType_Def not in ns0.FormatVmfs_Dec.__bases__: + bases = list(ns0.FormatVmfs_Dec.__bases__) + bases.insert(0, ns0.FormatVmfsRequestType_Def) + ns0.FormatVmfs_Dec.__bases__ = tuple(bases) + + ns0.FormatVmfsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "FormatVmfs_Dec_Holder" + + class FormatVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "FormatVmfsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.FormatVmfsResponse_Dec.schema + TClist = [GTD("urn:vim25","HostVmfsVolume",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","FormatVmfsResponse") + kw["aname"] = "_FormatVmfsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "FormatVmfsResponse_Holder" + self.pyclass = Holder + + class RescanVmfs_Dec(ElementDeclaration): + literal = "RescanVmfs" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RescanVmfs") + kw["aname"] = "_RescanVmfs" + if ns0.RescanVmfsRequestType_Def not in ns0.RescanVmfs_Dec.__bases__: + bases = list(ns0.RescanVmfs_Dec.__bases__) + bases.insert(0, ns0.RescanVmfsRequestType_Def) + ns0.RescanVmfs_Dec.__bases__ = tuple(bases) + + ns0.RescanVmfsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RescanVmfs_Dec_Holder" + + class RescanVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RescanVmfsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RescanVmfsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RescanVmfsResponse") + kw["aname"] = "_RescanVmfsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RescanVmfsResponse_Holder" + self.pyclass = Holder + + class AttachVmfsExtent_Dec(ElementDeclaration): + literal = "AttachVmfsExtent" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AttachVmfsExtent") + kw["aname"] = "_AttachVmfsExtent" + if ns0.AttachVmfsExtentRequestType_Def not in ns0.AttachVmfsExtent_Dec.__bases__: + bases = list(ns0.AttachVmfsExtent_Dec.__bases__) + bases.insert(0, ns0.AttachVmfsExtentRequestType_Def) + ns0.AttachVmfsExtent_Dec.__bases__ = tuple(bases) + + ns0.AttachVmfsExtentRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AttachVmfsExtent_Dec_Holder" + + class AttachVmfsExtentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AttachVmfsExtentResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AttachVmfsExtentResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AttachVmfsExtentResponse") + kw["aname"] = "_AttachVmfsExtentResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AttachVmfsExtentResponse_Holder" + self.pyclass = Holder + + class ExpandVmfsExtent_Dec(ElementDeclaration): + literal = "ExpandVmfsExtent" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ExpandVmfsExtent") + kw["aname"] = "_ExpandVmfsExtent" + if ns0.ExpandVmfsExtentRequestType_Def not in ns0.ExpandVmfsExtent_Dec.__bases__: + bases = list(ns0.ExpandVmfsExtent_Dec.__bases__) + bases.insert(0, ns0.ExpandVmfsExtentRequestType_Def) + ns0.ExpandVmfsExtent_Dec.__bases__ = tuple(bases) + + ns0.ExpandVmfsExtentRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ExpandVmfsExtent_Dec_Holder" + + class ExpandVmfsExtentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ExpandVmfsExtentResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ExpandVmfsExtentResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ExpandVmfsExtentResponse") + kw["aname"] = "_ExpandVmfsExtentResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ExpandVmfsExtentResponse_Holder" + self.pyclass = Holder + + class UpgradeVmfs_Dec(ElementDeclaration): + literal = "UpgradeVmfs" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpgradeVmfs") + kw["aname"] = "_UpgradeVmfs" + if ns0.UpgradeVmfsRequestType_Def not in ns0.UpgradeVmfs_Dec.__bases__: + bases = list(ns0.UpgradeVmfs_Dec.__bases__) + bases.insert(0, ns0.UpgradeVmfsRequestType_Def) + ns0.UpgradeVmfs_Dec.__bases__ = tuple(bases) + + ns0.UpgradeVmfsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVmfs_Dec_Holder" + + class UpgradeVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpgradeVmfsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpgradeVmfsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpgradeVmfsResponse") + kw["aname"] = "_UpgradeVmfsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpgradeVmfsResponse_Holder" + self.pyclass = Holder + + class UpgradeVmLayout_Dec(ElementDeclaration): + literal = "UpgradeVmLayout" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpgradeVmLayout") + kw["aname"] = "_UpgradeVmLayout" + if ns0.UpgradeVmLayoutRequestType_Def not in ns0.UpgradeVmLayout_Dec.__bases__: + bases = list(ns0.UpgradeVmLayout_Dec.__bases__) + bases.insert(0, ns0.UpgradeVmLayoutRequestType_Def) + ns0.UpgradeVmLayout_Dec.__bases__ = tuple(bases) + + ns0.UpgradeVmLayoutRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVmLayout_Dec_Holder" + + class UpgradeVmLayoutResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpgradeVmLayoutResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpgradeVmLayoutResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpgradeVmLayoutResponse") + kw["aname"] = "_UpgradeVmLayoutResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpgradeVmLayoutResponse_Holder" + self.pyclass = Holder + + class QueryUnresolvedVmfsVolume_Dec(ElementDeclaration): + literal = "QueryUnresolvedVmfsVolume" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolume") + kw["aname"] = "_QueryUnresolvedVmfsVolume" + if ns0.QueryUnresolvedVmfsVolumeRequestType_Def not in ns0.QueryUnresolvedVmfsVolume_Dec.__bases__: + bases = list(ns0.QueryUnresolvedVmfsVolume_Dec.__bases__) + bases.insert(0, ns0.QueryUnresolvedVmfsVolumeRequestType_Def) + ns0.QueryUnresolvedVmfsVolume_Dec.__bases__ = tuple(bases) + + ns0.QueryUnresolvedVmfsVolumeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryUnresolvedVmfsVolume_Dec_Holder" + + class QueryUnresolvedVmfsVolumeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryUnresolvedVmfsVolumeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryUnresolvedVmfsVolumeResponse_Dec.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsVolume",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolumeResponse") + kw["aname"] = "_QueryUnresolvedVmfsVolumeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryUnresolvedVmfsVolumeResponse_Holder" + self.pyclass = Holder + + class ResolveMultipleUnresolvedVmfsVolumes_Dec(ElementDeclaration): + literal = "ResolveMultipleUnresolvedVmfsVolumes" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResolveMultipleUnresolvedVmfsVolumes") + kw["aname"] = "_ResolveMultipleUnresolvedVmfsVolumes" + if ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def not in ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec.__bases__: + bases = list(ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec.__bases__) + bases.insert(0, ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def) + ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec.__bases__ = tuple(bases) + + ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResolveMultipleUnresolvedVmfsVolumes_Dec_Holder" + + class ResolveMultipleUnresolvedVmfsVolumesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResolveMultipleUnresolvedVmfsVolumesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResolveMultipleUnresolvedVmfsVolumesResponse_Dec.schema + TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ResolveMultipleUnresolvedVmfsVolumesResponse") + kw["aname"] = "_ResolveMultipleUnresolvedVmfsVolumesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ResolveMultipleUnresolvedVmfsVolumesResponse_Holder" + self.pyclass = Holder + + class UnmountForceMountedVmfsVolume_Dec(ElementDeclaration): + literal = "UnmountForceMountedVmfsVolume" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UnmountForceMountedVmfsVolume") + kw["aname"] = "_UnmountForceMountedVmfsVolume" + if ns0.UnmountForceMountedVmfsVolumeRequestType_Def not in ns0.UnmountForceMountedVmfsVolume_Dec.__bases__: + bases = list(ns0.UnmountForceMountedVmfsVolume_Dec.__bases__) + bases.insert(0, ns0.UnmountForceMountedVmfsVolumeRequestType_Def) + ns0.UnmountForceMountedVmfsVolume_Dec.__bases__ = tuple(bases) + + ns0.UnmountForceMountedVmfsVolumeRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UnmountForceMountedVmfsVolume_Dec_Holder" + + class UnmountForceMountedVmfsVolumeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UnmountForceMountedVmfsVolumeResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UnmountForceMountedVmfsVolumeResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UnmountForceMountedVmfsVolumeResponse") + kw["aname"] = "_UnmountForceMountedVmfsVolumeResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UnmountForceMountedVmfsVolumeResponse_Holder" + self.pyclass = Holder + + class RescanHba_Dec(ElementDeclaration): + literal = "RescanHba" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RescanHba") + kw["aname"] = "_RescanHba" + if ns0.RescanHbaRequestType_Def not in ns0.RescanHba_Dec.__bases__: + bases = list(ns0.RescanHba_Dec.__bases__) + bases.insert(0, ns0.RescanHbaRequestType_Def) + ns0.RescanHba_Dec.__bases__ = tuple(bases) + + ns0.RescanHbaRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RescanHba_Dec_Holder" + + class RescanHbaResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RescanHbaResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RescanHbaResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RescanHbaResponse") + kw["aname"] = "_RescanHbaResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RescanHbaResponse_Holder" + self.pyclass = Holder + + class RescanAllHba_Dec(ElementDeclaration): + literal = "RescanAllHba" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RescanAllHba") + kw["aname"] = "_RescanAllHba" + if ns0.RescanAllHbaRequestType_Def not in ns0.RescanAllHba_Dec.__bases__: + bases = list(ns0.RescanAllHba_Dec.__bases__) + bases.insert(0, ns0.RescanAllHbaRequestType_Def) + ns0.RescanAllHba_Dec.__bases__ = tuple(bases) + + ns0.RescanAllHbaRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RescanAllHba_Dec_Holder" + + class RescanAllHbaResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RescanAllHbaResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RescanAllHbaResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RescanAllHbaResponse") + kw["aname"] = "_RescanAllHbaResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RescanAllHbaResponse_Holder" + self.pyclass = Holder + + class UpdateSoftwareInternetScsiEnabled_Dec(ElementDeclaration): + literal = "UpdateSoftwareInternetScsiEnabled" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateSoftwareInternetScsiEnabled") + kw["aname"] = "_UpdateSoftwareInternetScsiEnabled" + if ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def not in ns0.UpdateSoftwareInternetScsiEnabled_Dec.__bases__: + bases = list(ns0.UpdateSoftwareInternetScsiEnabled_Dec.__bases__) + bases.insert(0, ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def) + ns0.UpdateSoftwareInternetScsiEnabled_Dec.__bases__ = tuple(bases) + + ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateSoftwareInternetScsiEnabled_Dec_Holder" + + class UpdateSoftwareInternetScsiEnabledResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateSoftwareInternetScsiEnabledResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateSoftwareInternetScsiEnabledResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateSoftwareInternetScsiEnabledResponse") + kw["aname"] = "_UpdateSoftwareInternetScsiEnabledResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateSoftwareInternetScsiEnabledResponse_Holder" + self.pyclass = Holder + + class UpdateInternetScsiDiscoveryProperties_Dec(ElementDeclaration): + literal = "UpdateInternetScsiDiscoveryProperties" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateInternetScsiDiscoveryProperties") + kw["aname"] = "_UpdateInternetScsiDiscoveryProperties" + if ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def not in ns0.UpdateInternetScsiDiscoveryProperties_Dec.__bases__: + bases = list(ns0.UpdateInternetScsiDiscoveryProperties_Dec.__bases__) + bases.insert(0, ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def) + ns0.UpdateInternetScsiDiscoveryProperties_Dec.__bases__ = tuple(bases) + + ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiDiscoveryProperties_Dec_Holder" + + class UpdateInternetScsiDiscoveryPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateInternetScsiDiscoveryPropertiesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateInternetScsiDiscoveryPropertiesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateInternetScsiDiscoveryPropertiesResponse") + kw["aname"] = "_UpdateInternetScsiDiscoveryPropertiesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateInternetScsiDiscoveryPropertiesResponse_Holder" + self.pyclass = Holder + + class UpdateInternetScsiAuthenticationProperties_Dec(ElementDeclaration): + literal = "UpdateInternetScsiAuthenticationProperties" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateInternetScsiAuthenticationProperties") + kw["aname"] = "_UpdateInternetScsiAuthenticationProperties" + if ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def not in ns0.UpdateInternetScsiAuthenticationProperties_Dec.__bases__: + bases = list(ns0.UpdateInternetScsiAuthenticationProperties_Dec.__bases__) + bases.insert(0, ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def) + ns0.UpdateInternetScsiAuthenticationProperties_Dec.__bases__ = tuple(bases) + + ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiAuthenticationProperties_Dec_Holder" + + class UpdateInternetScsiAuthenticationPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateInternetScsiAuthenticationPropertiesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateInternetScsiAuthenticationPropertiesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateInternetScsiAuthenticationPropertiesResponse") + kw["aname"] = "_UpdateInternetScsiAuthenticationPropertiesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateInternetScsiAuthenticationPropertiesResponse_Holder" + self.pyclass = Holder + + class UpdateInternetScsiDigestProperties_Dec(ElementDeclaration): + literal = "UpdateInternetScsiDigestProperties" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateInternetScsiDigestProperties") + kw["aname"] = "_UpdateInternetScsiDigestProperties" + if ns0.UpdateInternetScsiDigestPropertiesRequestType_Def not in ns0.UpdateInternetScsiDigestProperties_Dec.__bases__: + bases = list(ns0.UpdateInternetScsiDigestProperties_Dec.__bases__) + bases.insert(0, ns0.UpdateInternetScsiDigestPropertiesRequestType_Def) + ns0.UpdateInternetScsiDigestProperties_Dec.__bases__ = tuple(bases) + + ns0.UpdateInternetScsiDigestPropertiesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiDigestProperties_Dec_Holder" + + class UpdateInternetScsiDigestPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateInternetScsiDigestPropertiesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateInternetScsiDigestPropertiesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateInternetScsiDigestPropertiesResponse") + kw["aname"] = "_UpdateInternetScsiDigestPropertiesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateInternetScsiDigestPropertiesResponse_Holder" + self.pyclass = Holder + + class UpdateInternetScsiAdvancedOptions_Dec(ElementDeclaration): + literal = "UpdateInternetScsiAdvancedOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateInternetScsiAdvancedOptions") + kw["aname"] = "_UpdateInternetScsiAdvancedOptions" + if ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def not in ns0.UpdateInternetScsiAdvancedOptions_Dec.__bases__: + bases = list(ns0.UpdateInternetScsiAdvancedOptions_Dec.__bases__) + bases.insert(0, ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def) + ns0.UpdateInternetScsiAdvancedOptions_Dec.__bases__ = tuple(bases) + + ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiAdvancedOptions_Dec_Holder" + + class UpdateInternetScsiAdvancedOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateInternetScsiAdvancedOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateInternetScsiAdvancedOptionsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateInternetScsiAdvancedOptionsResponse") + kw["aname"] = "_UpdateInternetScsiAdvancedOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateInternetScsiAdvancedOptionsResponse_Holder" + self.pyclass = Holder + + class UpdateInternetScsiIPProperties_Dec(ElementDeclaration): + literal = "UpdateInternetScsiIPProperties" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateInternetScsiIPProperties") + kw["aname"] = "_UpdateInternetScsiIPProperties" + if ns0.UpdateInternetScsiIPPropertiesRequestType_Def not in ns0.UpdateInternetScsiIPProperties_Dec.__bases__: + bases = list(ns0.UpdateInternetScsiIPProperties_Dec.__bases__) + bases.insert(0, ns0.UpdateInternetScsiIPPropertiesRequestType_Def) + ns0.UpdateInternetScsiIPProperties_Dec.__bases__ = tuple(bases) + + ns0.UpdateInternetScsiIPPropertiesRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiIPProperties_Dec_Holder" + + class UpdateInternetScsiIPPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateInternetScsiIPPropertiesResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateInternetScsiIPPropertiesResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateInternetScsiIPPropertiesResponse") + kw["aname"] = "_UpdateInternetScsiIPPropertiesResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateInternetScsiIPPropertiesResponse_Holder" + self.pyclass = Holder + + class UpdateInternetScsiName_Dec(ElementDeclaration): + literal = "UpdateInternetScsiName" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateInternetScsiName") + kw["aname"] = "_UpdateInternetScsiName" + if ns0.UpdateInternetScsiNameRequestType_Def not in ns0.UpdateInternetScsiName_Dec.__bases__: + bases = list(ns0.UpdateInternetScsiName_Dec.__bases__) + bases.insert(0, ns0.UpdateInternetScsiNameRequestType_Def) + ns0.UpdateInternetScsiName_Dec.__bases__ = tuple(bases) + + ns0.UpdateInternetScsiNameRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiName_Dec_Holder" + + class UpdateInternetScsiNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateInternetScsiNameResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateInternetScsiNameResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateInternetScsiNameResponse") + kw["aname"] = "_UpdateInternetScsiNameResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateInternetScsiNameResponse_Holder" + self.pyclass = Holder + + class UpdateInternetScsiAlias_Dec(ElementDeclaration): + literal = "UpdateInternetScsiAlias" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateInternetScsiAlias") + kw["aname"] = "_UpdateInternetScsiAlias" + if ns0.UpdateInternetScsiAliasRequestType_Def not in ns0.UpdateInternetScsiAlias_Dec.__bases__: + bases = list(ns0.UpdateInternetScsiAlias_Dec.__bases__) + bases.insert(0, ns0.UpdateInternetScsiAliasRequestType_Def) + ns0.UpdateInternetScsiAlias_Dec.__bases__ = tuple(bases) + + ns0.UpdateInternetScsiAliasRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiAlias_Dec_Holder" + + class UpdateInternetScsiAliasResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateInternetScsiAliasResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateInternetScsiAliasResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateInternetScsiAliasResponse") + kw["aname"] = "_UpdateInternetScsiAliasResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateInternetScsiAliasResponse_Holder" + self.pyclass = Holder + + class AddInternetScsiSendTargets_Dec(ElementDeclaration): + literal = "AddInternetScsiSendTargets" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddInternetScsiSendTargets") + kw["aname"] = "_AddInternetScsiSendTargets" + if ns0.AddInternetScsiSendTargetsRequestType_Def not in ns0.AddInternetScsiSendTargets_Dec.__bases__: + bases = list(ns0.AddInternetScsiSendTargets_Dec.__bases__) + bases.insert(0, ns0.AddInternetScsiSendTargetsRequestType_Def) + ns0.AddInternetScsiSendTargets_Dec.__bases__ = tuple(bases) + + ns0.AddInternetScsiSendTargetsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddInternetScsiSendTargets_Dec_Holder" + + class AddInternetScsiSendTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddInternetScsiSendTargetsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddInternetScsiSendTargetsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AddInternetScsiSendTargetsResponse") + kw["aname"] = "_AddInternetScsiSendTargetsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AddInternetScsiSendTargetsResponse_Holder" + self.pyclass = Holder + + class RemoveInternetScsiSendTargets_Dec(ElementDeclaration): + literal = "RemoveInternetScsiSendTargets" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveInternetScsiSendTargets") + kw["aname"] = "_RemoveInternetScsiSendTargets" + if ns0.RemoveInternetScsiSendTargetsRequestType_Def not in ns0.RemoveInternetScsiSendTargets_Dec.__bases__: + bases = list(ns0.RemoveInternetScsiSendTargets_Dec.__bases__) + bases.insert(0, ns0.RemoveInternetScsiSendTargetsRequestType_Def) + ns0.RemoveInternetScsiSendTargets_Dec.__bases__ = tuple(bases) + + ns0.RemoveInternetScsiSendTargetsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveInternetScsiSendTargets_Dec_Holder" + + class RemoveInternetScsiSendTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveInternetScsiSendTargetsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveInternetScsiSendTargetsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveInternetScsiSendTargetsResponse") + kw["aname"] = "_RemoveInternetScsiSendTargetsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveInternetScsiSendTargetsResponse_Holder" + self.pyclass = Holder + + class AddInternetScsiStaticTargets_Dec(ElementDeclaration): + literal = "AddInternetScsiStaticTargets" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","AddInternetScsiStaticTargets") + kw["aname"] = "_AddInternetScsiStaticTargets" + if ns0.AddInternetScsiStaticTargetsRequestType_Def not in ns0.AddInternetScsiStaticTargets_Dec.__bases__: + bases = list(ns0.AddInternetScsiStaticTargets_Dec.__bases__) + bases.insert(0, ns0.AddInternetScsiStaticTargetsRequestType_Def) + ns0.AddInternetScsiStaticTargets_Dec.__bases__ = tuple(bases) + + ns0.AddInternetScsiStaticTargetsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "AddInternetScsiStaticTargets_Dec_Holder" + + class AddInternetScsiStaticTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "AddInternetScsiStaticTargetsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.AddInternetScsiStaticTargetsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","AddInternetScsiStaticTargetsResponse") + kw["aname"] = "_AddInternetScsiStaticTargetsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "AddInternetScsiStaticTargetsResponse_Holder" + self.pyclass = Holder + + class RemoveInternetScsiStaticTargets_Dec(ElementDeclaration): + literal = "RemoveInternetScsiStaticTargets" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveInternetScsiStaticTargets") + kw["aname"] = "_RemoveInternetScsiStaticTargets" + if ns0.RemoveInternetScsiStaticTargetsRequestType_Def not in ns0.RemoveInternetScsiStaticTargets_Dec.__bases__: + bases = list(ns0.RemoveInternetScsiStaticTargets_Dec.__bases__) + bases.insert(0, ns0.RemoveInternetScsiStaticTargetsRequestType_Def) + ns0.RemoveInternetScsiStaticTargets_Dec.__bases__ = tuple(bases) + + ns0.RemoveInternetScsiStaticTargetsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveInternetScsiStaticTargets_Dec_Holder" + + class RemoveInternetScsiStaticTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveInternetScsiStaticTargetsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveInternetScsiStaticTargetsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveInternetScsiStaticTargetsResponse") + kw["aname"] = "_RemoveInternetScsiStaticTargetsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveInternetScsiStaticTargetsResponse_Holder" + self.pyclass = Holder + + class EnableMultipathPath_Dec(ElementDeclaration): + literal = "EnableMultipathPath" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","EnableMultipathPath") + kw["aname"] = "_EnableMultipathPath" + if ns0.EnableMultipathPathRequestType_Def not in ns0.EnableMultipathPath_Dec.__bases__: + bases = list(ns0.EnableMultipathPath_Dec.__bases__) + bases.insert(0, ns0.EnableMultipathPathRequestType_Def) + ns0.EnableMultipathPath_Dec.__bases__ = tuple(bases) + + ns0.EnableMultipathPathRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "EnableMultipathPath_Dec_Holder" + + class EnableMultipathPathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "EnableMultipathPathResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.EnableMultipathPathResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","EnableMultipathPathResponse") + kw["aname"] = "_EnableMultipathPathResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "EnableMultipathPathResponse_Holder" + self.pyclass = Holder + + class DisableMultipathPath_Dec(ElementDeclaration): + literal = "DisableMultipathPath" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DisableMultipathPath") + kw["aname"] = "_DisableMultipathPath" + if ns0.DisableMultipathPathRequestType_Def not in ns0.DisableMultipathPath_Dec.__bases__: + bases = list(ns0.DisableMultipathPath_Dec.__bases__) + bases.insert(0, ns0.DisableMultipathPathRequestType_Def) + ns0.DisableMultipathPath_Dec.__bases__ = tuple(bases) + + ns0.DisableMultipathPathRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DisableMultipathPath_Dec_Holder" + + class DisableMultipathPathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DisableMultipathPathResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DisableMultipathPathResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DisableMultipathPathResponse") + kw["aname"] = "_DisableMultipathPathResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DisableMultipathPathResponse_Holder" + self.pyclass = Holder + + class SetMultipathLunPolicy_Dec(ElementDeclaration): + literal = "SetMultipathLunPolicy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SetMultipathLunPolicy") + kw["aname"] = "_SetMultipathLunPolicy" + if ns0.SetMultipathLunPolicyRequestType_Def not in ns0.SetMultipathLunPolicy_Dec.__bases__: + bases = list(ns0.SetMultipathLunPolicy_Dec.__bases__) + bases.insert(0, ns0.SetMultipathLunPolicyRequestType_Def) + ns0.SetMultipathLunPolicy_Dec.__bases__ = tuple(bases) + + ns0.SetMultipathLunPolicyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SetMultipathLunPolicy_Dec_Holder" + + class SetMultipathLunPolicyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SetMultipathLunPolicyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SetMultipathLunPolicyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SetMultipathLunPolicyResponse") + kw["aname"] = "_SetMultipathLunPolicyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SetMultipathLunPolicyResponse_Holder" + self.pyclass = Holder + + class QueryPathSelectionPolicyOptions_Dec(ElementDeclaration): + literal = "QueryPathSelectionPolicyOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryPathSelectionPolicyOptions") + kw["aname"] = "_QueryPathSelectionPolicyOptions" + if ns0.QueryPathSelectionPolicyOptionsRequestType_Def not in ns0.QueryPathSelectionPolicyOptions_Dec.__bases__: + bases = list(ns0.QueryPathSelectionPolicyOptions_Dec.__bases__) + bases.insert(0, ns0.QueryPathSelectionPolicyOptionsRequestType_Def) + ns0.QueryPathSelectionPolicyOptions_Dec.__bases__ = tuple(bases) + + ns0.QueryPathSelectionPolicyOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryPathSelectionPolicyOptions_Dec_Holder" + + class QueryPathSelectionPolicyOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryPathSelectionPolicyOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryPathSelectionPolicyOptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","HostPathSelectionPolicyOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryPathSelectionPolicyOptionsResponse") + kw["aname"] = "_QueryPathSelectionPolicyOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryPathSelectionPolicyOptionsResponse_Holder" + self.pyclass = Holder + + class QueryStorageArrayTypePolicyOptions_Dec(ElementDeclaration): + literal = "QueryStorageArrayTypePolicyOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryStorageArrayTypePolicyOptions") + kw["aname"] = "_QueryStorageArrayTypePolicyOptions" + if ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def not in ns0.QueryStorageArrayTypePolicyOptions_Dec.__bases__: + bases = list(ns0.QueryStorageArrayTypePolicyOptions_Dec.__bases__) + bases.insert(0, ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def) + ns0.QueryStorageArrayTypePolicyOptions_Dec.__bases__ = tuple(bases) + + ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryStorageArrayTypePolicyOptions_Dec_Holder" + + class QueryStorageArrayTypePolicyOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryStorageArrayTypePolicyOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryStorageArrayTypePolicyOptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","HostStorageArrayTypePolicyOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryStorageArrayTypePolicyOptionsResponse") + kw["aname"] = "_QueryStorageArrayTypePolicyOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryStorageArrayTypePolicyOptionsResponse_Holder" + self.pyclass = Holder + + class UpdateScsiLunDisplayName_Dec(ElementDeclaration): + literal = "UpdateScsiLunDisplayName" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateScsiLunDisplayName") + kw["aname"] = "_UpdateScsiLunDisplayName" + if ns0.UpdateScsiLunDisplayNameRequestType_Def not in ns0.UpdateScsiLunDisplayName_Dec.__bases__: + bases = list(ns0.UpdateScsiLunDisplayName_Dec.__bases__) + bases.insert(0, ns0.UpdateScsiLunDisplayNameRequestType_Def) + ns0.UpdateScsiLunDisplayName_Dec.__bases__ = tuple(bases) + + ns0.UpdateScsiLunDisplayNameRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateScsiLunDisplayName_Dec_Holder" + + class UpdateScsiLunDisplayNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateScsiLunDisplayNameResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateScsiLunDisplayNameResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateScsiLunDisplayNameResponse") + kw["aname"] = "_UpdateScsiLunDisplayNameResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateScsiLunDisplayNameResponse_Holder" + self.pyclass = Holder + + class RefreshStorageSystem_Dec(ElementDeclaration): + literal = "RefreshStorageSystem" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RefreshStorageSystem") + kw["aname"] = "_RefreshStorageSystem" + if ns0.RefreshStorageSystemRequestType_Def not in ns0.RefreshStorageSystem_Dec.__bases__: + bases = list(ns0.RefreshStorageSystem_Dec.__bases__) + bases.insert(0, ns0.RefreshStorageSystemRequestType_Def) + ns0.RefreshStorageSystem_Dec.__bases__ = tuple(bases) + + ns0.RefreshStorageSystemRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RefreshStorageSystem_Dec_Holder" + + class RefreshStorageSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RefreshStorageSystemResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RefreshStorageSystemResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RefreshStorageSystemResponse") + kw["aname"] = "_RefreshStorageSystemResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RefreshStorageSystemResponse_Holder" + self.pyclass = Holder + + class UpdateIpConfig_Dec(ElementDeclaration): + literal = "UpdateIpConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateIpConfig") + kw["aname"] = "_UpdateIpConfig" + if ns0.UpdateIpConfigRequestType_Def not in ns0.UpdateIpConfig_Dec.__bases__: + bases = list(ns0.UpdateIpConfig_Dec.__bases__) + bases.insert(0, ns0.UpdateIpConfigRequestType_Def) + ns0.UpdateIpConfig_Dec.__bases__ = tuple(bases) + + ns0.UpdateIpConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpConfig_Dec_Holder" + + class UpdateIpConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateIpConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateIpConfigResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateIpConfigResponse") + kw["aname"] = "_UpdateIpConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateIpConfigResponse_Holder" + self.pyclass = Holder + + class SelectVnic_Dec(ElementDeclaration): + literal = "SelectVnic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","SelectVnic") + kw["aname"] = "_SelectVnic" + if ns0.SelectVnicRequestType_Def not in ns0.SelectVnic_Dec.__bases__: + bases = list(ns0.SelectVnic_Dec.__bases__) + bases.insert(0, ns0.SelectVnicRequestType_Def) + ns0.SelectVnic_Dec.__bases__ = tuple(bases) + + ns0.SelectVnicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "SelectVnic_Dec_Holder" + + class SelectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "SelectVnicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.SelectVnicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","SelectVnicResponse") + kw["aname"] = "_SelectVnicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "SelectVnicResponse_Holder" + self.pyclass = Holder + + class DeselectVnic_Dec(ElementDeclaration): + literal = "DeselectVnic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DeselectVnic") + kw["aname"] = "_DeselectVnic" + if ns0.DeselectVnicRequestType_Def not in ns0.DeselectVnic_Dec.__bases__: + bases = list(ns0.DeselectVnic_Dec.__bases__) + bases.insert(0, ns0.DeselectVnicRequestType_Def) + ns0.DeselectVnic_Dec.__bases__ = tuple(bases) + + ns0.DeselectVnicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DeselectVnic_Dec_Holder" + + class DeselectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DeselectVnicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DeselectVnicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DeselectVnicResponse") + kw["aname"] = "_DeselectVnicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DeselectVnicResponse_Holder" + self.pyclass = Holder + + class QueryNetConfig_Dec(ElementDeclaration): + literal = "QueryNetConfig" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryNetConfig") + kw["aname"] = "_QueryNetConfig" + if ns0.QueryNetConfigRequestType_Def not in ns0.QueryNetConfig_Dec.__bases__: + bases = list(ns0.QueryNetConfig_Dec.__bases__) + bases.insert(0, ns0.QueryNetConfigRequestType_Def) + ns0.QueryNetConfig_Dec.__bases__ = tuple(bases) + + ns0.QueryNetConfigRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryNetConfig_Dec_Holder" + + class QueryNetConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryNetConfigResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryNetConfigResponse_Dec.schema + TClist = [GTD("urn:vim25","VirtualNicManagerNetConfig",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryNetConfigResponse") + kw["aname"] = "_QueryNetConfigResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryNetConfigResponse_Holder" + self.pyclass = Holder + + class VirtualNicManagerSelectVnic_Dec(ElementDeclaration): + literal = "VirtualNicManagerSelectVnic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VirtualNicManagerSelectVnic") + kw["aname"] = "_VirtualNicManagerSelectVnic" + if ns0.VirtualNicManagerSelectVnicRequestType_Def not in ns0.VirtualNicManagerSelectVnic_Dec.__bases__: + bases = list(ns0.VirtualNicManagerSelectVnic_Dec.__bases__) + bases.insert(0, ns0.VirtualNicManagerSelectVnicRequestType_Def) + ns0.VirtualNicManagerSelectVnic_Dec.__bases__ = tuple(bases) + + ns0.VirtualNicManagerSelectVnicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VirtualNicManagerSelectVnic_Dec_Holder" + + class VirtualNicManagerSelectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "VirtualNicManagerSelectVnicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.VirtualNicManagerSelectVnicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","VirtualNicManagerSelectVnicResponse") + kw["aname"] = "_VirtualNicManagerSelectVnicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "VirtualNicManagerSelectVnicResponse_Holder" + self.pyclass = Holder + + class VirtualNicManagerDeselectVnic_Dec(ElementDeclaration): + literal = "VirtualNicManagerDeselectVnic" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","VirtualNicManagerDeselectVnic") + kw["aname"] = "_VirtualNicManagerDeselectVnic" + if ns0.VirtualNicManagerDeselectVnicRequestType_Def not in ns0.VirtualNicManagerDeselectVnic_Dec.__bases__: + bases = list(ns0.VirtualNicManagerDeselectVnic_Dec.__bases__) + bases.insert(0, ns0.VirtualNicManagerDeselectVnicRequestType_Def) + ns0.VirtualNicManagerDeselectVnic_Dec.__bases__ = tuple(bases) + + ns0.VirtualNicManagerDeselectVnicRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "VirtualNicManagerDeselectVnic_Dec_Holder" + + class VirtualNicManagerDeselectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "VirtualNicManagerDeselectVnicResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.VirtualNicManagerDeselectVnicResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","VirtualNicManagerDeselectVnicResponse") + kw["aname"] = "_VirtualNicManagerDeselectVnicResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "VirtualNicManagerDeselectVnicResponse_Holder" + self.pyclass = Holder + + class QueryOptions_Dec(ElementDeclaration): + literal = "QueryOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryOptions") + kw["aname"] = "_QueryOptions" + if ns0.QueryOptionsRequestType_Def not in ns0.QueryOptions_Dec.__bases__: + bases = list(ns0.QueryOptions_Dec.__bases__) + bases.insert(0, ns0.QueryOptionsRequestType_Def) + ns0.QueryOptions_Dec.__bases__ = tuple(bases) + + ns0.QueryOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryOptions_Dec_Holder" + + class QueryOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryOptionsResponse_Dec.schema + TClist = [GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryOptionsResponse") + kw["aname"] = "_QueryOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryOptionsResponse_Holder" + self.pyclass = Holder + + class UpdateOptions_Dec(ElementDeclaration): + literal = "UpdateOptions" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","UpdateOptions") + kw["aname"] = "_UpdateOptions" + if ns0.UpdateOptionsRequestType_Def not in ns0.UpdateOptions_Dec.__bases__: + bases = list(ns0.UpdateOptions_Dec.__bases__) + bases.insert(0, ns0.UpdateOptionsRequestType_Def) + ns0.UpdateOptions_Dec.__bases__ = tuple(bases) + + ns0.UpdateOptionsRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "UpdateOptions_Dec_Holder" + + class UpdateOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "UpdateOptionsResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.UpdateOptionsResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","UpdateOptionsResponse") + kw["aname"] = "_UpdateOptionsResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "UpdateOptionsResponse_Holder" + self.pyclass = Holder + + class ComplianceManagerCheckCompliance_Dec(ElementDeclaration): + literal = "ComplianceManagerCheckCompliance" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ComplianceManagerCheckCompliance") + kw["aname"] = "_ComplianceManagerCheckCompliance" + if ns0.ComplianceManagerCheckComplianceRequestType_Def not in ns0.ComplianceManagerCheckCompliance_Dec.__bases__: + bases = list(ns0.ComplianceManagerCheckCompliance_Dec.__bases__) + bases.insert(0, ns0.ComplianceManagerCheckComplianceRequestType_Def) + ns0.ComplianceManagerCheckCompliance_Dec.__bases__ = tuple(bases) + + ns0.ComplianceManagerCheckComplianceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerCheckCompliance_Dec_Holder" + + class ComplianceManagerCheckComplianceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ComplianceManagerCheckComplianceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ComplianceManagerCheckComplianceResponse_Dec.schema + TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ComplianceManagerCheckComplianceResponse") + kw["aname"] = "_ComplianceManagerCheckComplianceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ComplianceManagerCheckComplianceResponse_Holder" + self.pyclass = Holder + + class ComplianceManagerCheckCompliance_Task_Dec(ElementDeclaration): + literal = "ComplianceManagerCheckCompliance_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ComplianceManagerCheckCompliance_Task") + kw["aname"] = "_ComplianceManagerCheckCompliance_Task" + if ns0.ComplianceManagerCheckComplianceRequestType_Def not in ns0.ComplianceManagerCheckCompliance_Task_Dec.__bases__: + bases = list(ns0.ComplianceManagerCheckCompliance_Task_Dec.__bases__) + bases.insert(0, ns0.ComplianceManagerCheckComplianceRequestType_Def) + ns0.ComplianceManagerCheckCompliance_Task_Dec.__bases__ = tuple(bases) + + ns0.ComplianceManagerCheckComplianceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerCheckCompliance_Task_Dec_Holder" + + class ComplianceManagerCheckCompliance_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ComplianceManagerCheckCompliance_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ComplianceManagerCheckCompliance_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ComplianceManagerCheckCompliance_TaskResponse") + kw["aname"] = "_ComplianceManagerCheckCompliance_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ComplianceManagerCheckCompliance_TaskResponse_Holder" + self.pyclass = Holder + + class ComplianceManagerQueryComplianceStatus_Dec(ElementDeclaration): + literal = "ComplianceManagerQueryComplianceStatus" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ComplianceManagerQueryComplianceStatus") + kw["aname"] = "_ComplianceManagerQueryComplianceStatus" + if ns0.ComplianceManagerQueryComplianceStatusRequestType_Def not in ns0.ComplianceManagerQueryComplianceStatus_Dec.__bases__: + bases = list(ns0.ComplianceManagerQueryComplianceStatus_Dec.__bases__) + bases.insert(0, ns0.ComplianceManagerQueryComplianceStatusRequestType_Def) + ns0.ComplianceManagerQueryComplianceStatus_Dec.__bases__ = tuple(bases) + + ns0.ComplianceManagerQueryComplianceStatusRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerQueryComplianceStatus_Dec_Holder" + + class ComplianceManagerQueryComplianceStatusResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ComplianceManagerQueryComplianceStatusResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ComplianceManagerQueryComplianceStatusResponse_Dec.schema + TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ComplianceManagerQueryComplianceStatusResponse") + kw["aname"] = "_ComplianceManagerQueryComplianceStatusResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ComplianceManagerQueryComplianceStatusResponse_Holder" + self.pyclass = Holder + + class ComplianceManagerClearComplianceStatus_Dec(ElementDeclaration): + literal = "ComplianceManagerClearComplianceStatus" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ComplianceManagerClearComplianceStatus") + kw["aname"] = "_ComplianceManagerClearComplianceStatus" + if ns0.ComplianceManagerClearComplianceStatusRequestType_Def not in ns0.ComplianceManagerClearComplianceStatus_Dec.__bases__: + bases = list(ns0.ComplianceManagerClearComplianceStatus_Dec.__bases__) + bases.insert(0, ns0.ComplianceManagerClearComplianceStatusRequestType_Def) + ns0.ComplianceManagerClearComplianceStatus_Dec.__bases__ = tuple(bases) + + ns0.ComplianceManagerClearComplianceStatusRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerClearComplianceStatus_Dec_Holder" + + class ComplianceManagerClearComplianceStatusResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ComplianceManagerClearComplianceStatusResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ComplianceManagerClearComplianceStatusResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ComplianceManagerClearComplianceStatusResponse") + kw["aname"] = "_ComplianceManagerClearComplianceStatusResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ComplianceManagerClearComplianceStatusResponse_Holder" + self.pyclass = Holder + + class ComplianceManagerQueryExpressionMetadata_Dec(ElementDeclaration): + literal = "ComplianceManagerQueryExpressionMetadata" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ComplianceManagerQueryExpressionMetadata") + kw["aname"] = "_ComplianceManagerQueryExpressionMetadata" + if ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def not in ns0.ComplianceManagerQueryExpressionMetadata_Dec.__bases__: + bases = list(ns0.ComplianceManagerQueryExpressionMetadata_Dec.__bases__) + bases.insert(0, ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def) + ns0.ComplianceManagerQueryExpressionMetadata_Dec.__bases__ = tuple(bases) + + ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerQueryExpressionMetadata_Dec_Holder" + + class ComplianceManagerQueryExpressionMetadataResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ComplianceManagerQueryExpressionMetadataResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ComplianceManagerQueryExpressionMetadataResponse_Dec.schema + TClist = [GTD("urn:vim25","ProfileExpressionMetadata",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ComplianceManagerQueryExpressionMetadataResponse") + kw["aname"] = "_ComplianceManagerQueryExpressionMetadataResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ComplianceManagerQueryExpressionMetadataResponse_Holder" + self.pyclass = Holder + + class ProfileDestroy_Dec(ElementDeclaration): + literal = "ProfileDestroy" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileDestroy") + kw["aname"] = "_ProfileDestroy" + if ns0.ProfileDestroyRequestType_Def not in ns0.ProfileDestroy_Dec.__bases__: + bases = list(ns0.ProfileDestroy_Dec.__bases__) + bases.insert(0, ns0.ProfileDestroyRequestType_Def) + ns0.ProfileDestroy_Dec.__bases__ = tuple(bases) + + ns0.ProfileDestroyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileDestroy_Dec_Holder" + + class ProfileDestroyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileDestroyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileDestroyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ProfileDestroyResponse") + kw["aname"] = "_ProfileDestroyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ProfileDestroyResponse_Holder" + self.pyclass = Holder + + class ProfileAssociate_Dec(ElementDeclaration): + literal = "ProfileAssociate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileAssociate") + kw["aname"] = "_ProfileAssociate" + if ns0.ProfileAssociateRequestType_Def not in ns0.ProfileAssociate_Dec.__bases__: + bases = list(ns0.ProfileAssociate_Dec.__bases__) + bases.insert(0, ns0.ProfileAssociateRequestType_Def) + ns0.ProfileAssociate_Dec.__bases__ = tuple(bases) + + ns0.ProfileAssociateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileAssociate_Dec_Holder" + + class ProfileAssociateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileAssociateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileAssociateResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ProfileAssociateResponse") + kw["aname"] = "_ProfileAssociateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ProfileAssociateResponse_Holder" + self.pyclass = Holder + + class ProfileDissociate_Dec(ElementDeclaration): + literal = "ProfileDissociate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileDissociate") + kw["aname"] = "_ProfileDissociate" + if ns0.ProfileDissociateRequestType_Def not in ns0.ProfileDissociate_Dec.__bases__: + bases = list(ns0.ProfileDissociate_Dec.__bases__) + bases.insert(0, ns0.ProfileDissociateRequestType_Def) + ns0.ProfileDissociate_Dec.__bases__ = tuple(bases) + + ns0.ProfileDissociateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileDissociate_Dec_Holder" + + class ProfileDissociateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileDissociateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileDissociateResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ProfileDissociateResponse") + kw["aname"] = "_ProfileDissociateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ProfileDissociateResponse_Holder" + self.pyclass = Holder + + class ProfileCheckCompliance_Dec(ElementDeclaration): + literal = "ProfileCheckCompliance" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileCheckCompliance") + kw["aname"] = "_ProfileCheckCompliance" + if ns0.ProfileCheckComplianceRequestType_Def not in ns0.ProfileCheckCompliance_Dec.__bases__: + bases = list(ns0.ProfileCheckCompliance_Dec.__bases__) + bases.insert(0, ns0.ProfileCheckComplianceRequestType_Def) + ns0.ProfileCheckCompliance_Dec.__bases__ = tuple(bases) + + ns0.ProfileCheckComplianceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileCheckCompliance_Dec_Holder" + + class ProfileCheckComplianceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileCheckComplianceResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileCheckComplianceResponse_Dec.schema + TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ProfileCheckComplianceResponse") + kw["aname"] = "_ProfileCheckComplianceResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ProfileCheckComplianceResponse_Holder" + self.pyclass = Holder + + class ProfileCheckCompliance_Task_Dec(ElementDeclaration): + literal = "ProfileCheckCompliance_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileCheckCompliance_Task") + kw["aname"] = "_ProfileCheckCompliance_Task" + if ns0.ProfileCheckComplianceRequestType_Def not in ns0.ProfileCheckCompliance_Task_Dec.__bases__: + bases = list(ns0.ProfileCheckCompliance_Task_Dec.__bases__) + bases.insert(0, ns0.ProfileCheckComplianceRequestType_Def) + ns0.ProfileCheckCompliance_Task_Dec.__bases__ = tuple(bases) + + ns0.ProfileCheckComplianceRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileCheckCompliance_Task_Dec_Holder" + + class ProfileCheckCompliance_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileCheckCompliance_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileCheckCompliance_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ProfileCheckCompliance_TaskResponse") + kw["aname"] = "_ProfileCheckCompliance_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ProfileCheckCompliance_TaskResponse_Holder" + self.pyclass = Holder + + class ProfileExportProfile_Dec(ElementDeclaration): + literal = "ProfileExportProfile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileExportProfile") + kw["aname"] = "_ProfileExportProfile" + if ns0.ProfileExportProfileRequestType_Def not in ns0.ProfileExportProfile_Dec.__bases__: + bases = list(ns0.ProfileExportProfile_Dec.__bases__) + bases.insert(0, ns0.ProfileExportProfileRequestType_Def) + ns0.ProfileExportProfile_Dec.__bases__ = tuple(bases) + + ns0.ProfileExportProfileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileExportProfile_Dec_Holder" + + class ProfileExportProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileExportProfileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileExportProfileResponse_Dec.schema + TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ProfileExportProfileResponse") + kw["aname"] = "_ProfileExportProfileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "ProfileExportProfileResponse_Holder" + self.pyclass = Holder + + class CreateProfile_Dec(ElementDeclaration): + literal = "CreateProfile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateProfile") + kw["aname"] = "_CreateProfile" + if ns0.CreateProfileRequestType_Def not in ns0.CreateProfile_Dec.__bases__: + bases = list(ns0.CreateProfile_Dec.__bases__) + bases.insert(0, ns0.CreateProfileRequestType_Def) + ns0.CreateProfile_Dec.__bases__ = tuple(bases) + + ns0.CreateProfileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateProfile_Dec_Holder" + + class CreateProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateProfileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateProfileResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateProfileResponse") + kw["aname"] = "_CreateProfileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateProfileResponse_Holder" + self.pyclass = Holder + + class ProfileQueryPolicyMetadata_Dec(ElementDeclaration): + literal = "ProfileQueryPolicyMetadata" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileQueryPolicyMetadata") + kw["aname"] = "_ProfileQueryPolicyMetadata" + if ns0.ProfileQueryPolicyMetadataRequestType_Def not in ns0.ProfileQueryPolicyMetadata_Dec.__bases__: + bases = list(ns0.ProfileQueryPolicyMetadata_Dec.__bases__) + bases.insert(0, ns0.ProfileQueryPolicyMetadataRequestType_Def) + ns0.ProfileQueryPolicyMetadata_Dec.__bases__ = tuple(bases) + + ns0.ProfileQueryPolicyMetadataRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileQueryPolicyMetadata_Dec_Holder" + + class ProfileQueryPolicyMetadataResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileQueryPolicyMetadataResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileQueryPolicyMetadataResponse_Dec.schema + TClist = [GTD("urn:vim25","ProfilePolicyMetadata",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ProfileQueryPolicyMetadataResponse") + kw["aname"] = "_ProfileQueryPolicyMetadataResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ProfileQueryPolicyMetadataResponse_Holder" + self.pyclass = Holder + + class ProfileFindAssociatedProfile_Dec(ElementDeclaration): + literal = "ProfileFindAssociatedProfile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ProfileFindAssociatedProfile") + kw["aname"] = "_ProfileFindAssociatedProfile" + if ns0.ProfileFindAssociatedProfileRequestType_Def not in ns0.ProfileFindAssociatedProfile_Dec.__bases__: + bases = list(ns0.ProfileFindAssociatedProfile_Dec.__bases__) + bases.insert(0, ns0.ProfileFindAssociatedProfileRequestType_Def) + ns0.ProfileFindAssociatedProfile_Dec.__bases__ = tuple(bases) + + ns0.ProfileFindAssociatedProfileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ProfileFindAssociatedProfile_Dec_Holder" + + class ProfileFindAssociatedProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ProfileFindAssociatedProfileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ProfileFindAssociatedProfileResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ProfileFindAssociatedProfileResponse") + kw["aname"] = "_ProfileFindAssociatedProfileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ProfileFindAssociatedProfileResponse_Holder" + self.pyclass = Holder + + class ClusterProfileUpdate_Dec(ElementDeclaration): + literal = "ClusterProfileUpdate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ClusterProfileUpdate") + kw["aname"] = "_ClusterProfileUpdate" + if ns0.ClusterProfileUpdateRequestType_Def not in ns0.ClusterProfileUpdate_Dec.__bases__: + bases = list(ns0.ClusterProfileUpdate_Dec.__bases__) + bases.insert(0, ns0.ClusterProfileUpdateRequestType_Def) + ns0.ClusterProfileUpdate_Dec.__bases__ = tuple(bases) + + ns0.ClusterProfileUpdateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ClusterProfileUpdate_Dec_Holder" + + class ClusterProfileUpdateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ClusterProfileUpdateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ClusterProfileUpdateResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ClusterProfileUpdateResponse") + kw["aname"] = "_ClusterProfileUpdateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ClusterProfileUpdateResponse_Holder" + self.pyclass = Holder + + class HostProfileUpdateReferenceHost_Dec(ElementDeclaration): + literal = "HostProfileUpdateReferenceHost" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileUpdateReferenceHost") + kw["aname"] = "_HostProfileUpdateReferenceHost" + if ns0.HostProfileUpdateReferenceHostRequestType_Def not in ns0.HostProfileUpdateReferenceHost_Dec.__bases__: + bases = list(ns0.HostProfileUpdateReferenceHost_Dec.__bases__) + bases.insert(0, ns0.HostProfileUpdateReferenceHostRequestType_Def) + ns0.HostProfileUpdateReferenceHost_Dec.__bases__ = tuple(bases) + + ns0.HostProfileUpdateReferenceHostRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileUpdateReferenceHost_Dec_Holder" + + class HostProfileUpdateReferenceHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileUpdateReferenceHostResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileUpdateReferenceHostResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","HostProfileUpdateReferenceHostResponse") + kw["aname"] = "_HostProfileUpdateReferenceHostResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "HostProfileUpdateReferenceHostResponse_Holder" + self.pyclass = Holder + + class HostProfileUpdate_Dec(ElementDeclaration): + literal = "HostProfileUpdate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileUpdate") + kw["aname"] = "_HostProfileUpdate" + if ns0.HostProfileUpdateRequestType_Def not in ns0.HostProfileUpdate_Dec.__bases__: + bases = list(ns0.HostProfileUpdate_Dec.__bases__) + bases.insert(0, ns0.HostProfileUpdateRequestType_Def) + ns0.HostProfileUpdate_Dec.__bases__ = tuple(bases) + + ns0.HostProfileUpdateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileUpdate_Dec_Holder" + + class HostProfileUpdateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileUpdateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileUpdateResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","HostProfileUpdateResponse") + kw["aname"] = "_HostProfileUpdateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "HostProfileUpdateResponse_Holder" + self.pyclass = Holder + + class HostProfileExecute_Dec(ElementDeclaration): + literal = "HostProfileExecute" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileExecute") + kw["aname"] = "_HostProfileExecute" + if ns0.HostProfileExecuteRequestType_Def not in ns0.HostProfileExecute_Dec.__bases__: + bases = list(ns0.HostProfileExecute_Dec.__bases__) + bases.insert(0, ns0.HostProfileExecuteRequestType_Def) + ns0.HostProfileExecute_Dec.__bases__ = tuple(bases) + + ns0.HostProfileExecuteRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileExecute_Dec_Holder" + + class HostProfileExecuteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileExecuteResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileExecuteResponse_Dec.schema + TClist = [GTD("urn:vim25","ProfileExecuteResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","HostProfileExecuteResponse") + kw["aname"] = "_HostProfileExecuteResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "HostProfileExecuteResponse_Holder" + self.pyclass = Holder + + class HostProfileApply_Dec(ElementDeclaration): + literal = "HostProfileApply" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileApply") + kw["aname"] = "_HostProfileApply" + if ns0.HostProfileApplyRequestType_Def not in ns0.HostProfileApply_Dec.__bases__: + bases = list(ns0.HostProfileApply_Dec.__bases__) + bases.insert(0, ns0.HostProfileApplyRequestType_Def) + ns0.HostProfileApply_Dec.__bases__ = tuple(bases) + + ns0.HostProfileApplyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileApply_Dec_Holder" + + class HostProfileApplyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileApplyResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileApplyResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","HostProfileApplyResponse") + kw["aname"] = "_HostProfileApplyResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "HostProfileApplyResponse_Holder" + self.pyclass = Holder + + class HostProfileApply_Task_Dec(ElementDeclaration): + literal = "HostProfileApply_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileApply_Task") + kw["aname"] = "_HostProfileApply_Task" + if ns0.HostProfileApplyRequestType_Def not in ns0.HostProfileApply_Task_Dec.__bases__: + bases = list(ns0.HostProfileApply_Task_Dec.__bases__) + bases.insert(0, ns0.HostProfileApplyRequestType_Def) + ns0.HostProfileApply_Task_Dec.__bases__ = tuple(bases) + + ns0.HostProfileApplyRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileApply_Task_Dec_Holder" + + class HostProfileApply_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileApply_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileApply_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","HostProfileApply_TaskResponse") + kw["aname"] = "_HostProfileApply_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "HostProfileApply_TaskResponse_Holder" + self.pyclass = Holder + + class HostProfileGenerateConfigTaskList_Dec(ElementDeclaration): + literal = "HostProfileGenerateConfigTaskList" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileGenerateConfigTaskList") + kw["aname"] = "_HostProfileGenerateConfigTaskList" + if ns0.HostProfileGenerateConfigTaskListRequestType_Def not in ns0.HostProfileGenerateConfigTaskList_Dec.__bases__: + bases = list(ns0.HostProfileGenerateConfigTaskList_Dec.__bases__) + bases.insert(0, ns0.HostProfileGenerateConfigTaskListRequestType_Def) + ns0.HostProfileGenerateConfigTaskList_Dec.__bases__ = tuple(bases) + + ns0.HostProfileGenerateConfigTaskListRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileGenerateConfigTaskList_Dec_Holder" + + class HostProfileGenerateConfigTaskListResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileGenerateConfigTaskListResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileGenerateConfigTaskListResponse_Dec.schema + TClist = [GTD("urn:vim25","HostProfileManagerConfigTaskList",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","HostProfileGenerateConfigTaskListResponse") + kw["aname"] = "_HostProfileGenerateConfigTaskListResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "HostProfileGenerateConfigTaskListResponse_Holder" + self.pyclass = Holder + + class HostProfileQueryProfileMetadata_Dec(ElementDeclaration): + literal = "HostProfileQueryProfileMetadata" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileQueryProfileMetadata") + kw["aname"] = "_HostProfileQueryProfileMetadata" + if ns0.HostProfileQueryProfileMetadataRequestType_Def not in ns0.HostProfileQueryProfileMetadata_Dec.__bases__: + bases = list(ns0.HostProfileQueryProfileMetadata_Dec.__bases__) + bases.insert(0, ns0.HostProfileQueryProfileMetadataRequestType_Def) + ns0.HostProfileQueryProfileMetadata_Dec.__bases__ = tuple(bases) + + ns0.HostProfileQueryProfileMetadataRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileQueryProfileMetadata_Dec_Holder" + + class HostProfileQueryProfileMetadataResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileQueryProfileMetadataResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileQueryProfileMetadataResponse_Dec.schema + TClist = [GTD("urn:vim25","ProfileMetadata",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","HostProfileQueryProfileMetadataResponse") + kw["aname"] = "_HostProfileQueryProfileMetadataResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "HostProfileQueryProfileMetadataResponse_Holder" + self.pyclass = Holder + + class HostProfileCreateDefaultProfile_Dec(ElementDeclaration): + literal = "HostProfileCreateDefaultProfile" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","HostProfileCreateDefaultProfile") + kw["aname"] = "_HostProfileCreateDefaultProfile" + if ns0.HostProfileCreateDefaultProfileRequestType_Def not in ns0.HostProfileCreateDefaultProfile_Dec.__bases__: + bases = list(ns0.HostProfileCreateDefaultProfile_Dec.__bases__) + bases.insert(0, ns0.HostProfileCreateDefaultProfileRequestType_Def) + ns0.HostProfileCreateDefaultProfile_Dec.__bases__ = tuple(bases) + + ns0.HostProfileCreateDefaultProfileRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "HostProfileCreateDefaultProfile_Dec_Holder" + + class HostProfileCreateDefaultProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "HostProfileCreateDefaultProfileResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.HostProfileCreateDefaultProfileResponse_Dec.schema + TClist = [GTD("urn:vim25","ApplyProfile",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","HostProfileCreateDefaultProfileResponse") + kw["aname"] = "_HostProfileCreateDefaultProfileResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "HostProfileCreateDefaultProfileResponse_Holder" + self.pyclass = Holder + + class RemoveScheduledTask_Dec(ElementDeclaration): + literal = "RemoveScheduledTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveScheduledTask") + kw["aname"] = "_RemoveScheduledTask" + if ns0.RemoveScheduledTaskRequestType_Def not in ns0.RemoveScheduledTask_Dec.__bases__: + bases = list(ns0.RemoveScheduledTask_Dec.__bases__) + bases.insert(0, ns0.RemoveScheduledTaskRequestType_Def) + ns0.RemoveScheduledTask_Dec.__bases__ = tuple(bases) + + ns0.RemoveScheduledTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveScheduledTask_Dec_Holder" + + class RemoveScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveScheduledTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveScheduledTaskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveScheduledTaskResponse") + kw["aname"] = "_RemoveScheduledTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveScheduledTaskResponse_Holder" + self.pyclass = Holder + + class ReconfigureScheduledTask_Dec(ElementDeclaration): + literal = "ReconfigureScheduledTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ReconfigureScheduledTask") + kw["aname"] = "_ReconfigureScheduledTask" + if ns0.ReconfigureScheduledTaskRequestType_Def not in ns0.ReconfigureScheduledTask_Dec.__bases__: + bases = list(ns0.ReconfigureScheduledTask_Dec.__bases__) + bases.insert(0, ns0.ReconfigureScheduledTaskRequestType_Def) + ns0.ReconfigureScheduledTask_Dec.__bases__ = tuple(bases) + + ns0.ReconfigureScheduledTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureScheduledTask_Dec_Holder" + + class ReconfigureScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ReconfigureScheduledTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ReconfigureScheduledTaskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ReconfigureScheduledTaskResponse") + kw["aname"] = "_ReconfigureScheduledTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ReconfigureScheduledTaskResponse_Holder" + self.pyclass = Holder + + class RunScheduledTask_Dec(ElementDeclaration): + literal = "RunScheduledTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RunScheduledTask") + kw["aname"] = "_RunScheduledTask" + if ns0.RunScheduledTaskRequestType_Def not in ns0.RunScheduledTask_Dec.__bases__: + bases = list(ns0.RunScheduledTask_Dec.__bases__) + bases.insert(0, ns0.RunScheduledTaskRequestType_Def) + ns0.RunScheduledTask_Dec.__bases__ = tuple(bases) + + ns0.RunScheduledTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RunScheduledTask_Dec_Holder" + + class RunScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RunScheduledTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RunScheduledTaskResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RunScheduledTaskResponse") + kw["aname"] = "_RunScheduledTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RunScheduledTaskResponse_Holder" + self.pyclass = Holder + + class CreateScheduledTask_Dec(ElementDeclaration): + literal = "CreateScheduledTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateScheduledTask") + kw["aname"] = "_CreateScheduledTask" + if ns0.CreateScheduledTaskRequestType_Def not in ns0.CreateScheduledTask_Dec.__bases__: + bases = list(ns0.CreateScheduledTask_Dec.__bases__) + bases.insert(0, ns0.CreateScheduledTaskRequestType_Def) + ns0.CreateScheduledTask_Dec.__bases__ = tuple(bases) + + ns0.CreateScheduledTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateScheduledTask_Dec_Holder" + + class CreateScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateScheduledTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateScheduledTaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateScheduledTaskResponse") + kw["aname"] = "_CreateScheduledTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateScheduledTaskResponse_Holder" + self.pyclass = Holder + + class RetrieveEntityScheduledTask_Dec(ElementDeclaration): + literal = "RetrieveEntityScheduledTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveEntityScheduledTask") + kw["aname"] = "_RetrieveEntityScheduledTask" + if ns0.RetrieveEntityScheduledTaskRequestType_Def not in ns0.RetrieveEntityScheduledTask_Dec.__bases__: + bases = list(ns0.RetrieveEntityScheduledTask_Dec.__bases__) + bases.insert(0, ns0.RetrieveEntityScheduledTaskRequestType_Def) + ns0.RetrieveEntityScheduledTask_Dec.__bases__ = tuple(bases) + + ns0.RetrieveEntityScheduledTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveEntityScheduledTask_Dec_Holder" + + class RetrieveEntityScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveEntityScheduledTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveEntityScheduledTaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveEntityScheduledTaskResponse") + kw["aname"] = "_RetrieveEntityScheduledTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveEntityScheduledTaskResponse_Holder" + self.pyclass = Holder + + class CreateObjectScheduledTask_Dec(ElementDeclaration): + literal = "CreateObjectScheduledTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateObjectScheduledTask") + kw["aname"] = "_CreateObjectScheduledTask" + if ns0.CreateObjectScheduledTaskRequestType_Def not in ns0.CreateObjectScheduledTask_Dec.__bases__: + bases = list(ns0.CreateObjectScheduledTask_Dec.__bases__) + bases.insert(0, ns0.CreateObjectScheduledTaskRequestType_Def) + ns0.CreateObjectScheduledTask_Dec.__bases__ = tuple(bases) + + ns0.CreateObjectScheduledTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateObjectScheduledTask_Dec_Holder" + + class CreateObjectScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateObjectScheduledTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateObjectScheduledTaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateObjectScheduledTaskResponse") + kw["aname"] = "_CreateObjectScheduledTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateObjectScheduledTaskResponse_Holder" + self.pyclass = Holder + + class RetrieveObjectScheduledTask_Dec(ElementDeclaration): + literal = "RetrieveObjectScheduledTask" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RetrieveObjectScheduledTask") + kw["aname"] = "_RetrieveObjectScheduledTask" + if ns0.RetrieveObjectScheduledTaskRequestType_Def not in ns0.RetrieveObjectScheduledTask_Dec.__bases__: + bases = list(ns0.RetrieveObjectScheduledTask_Dec.__bases__) + bases.insert(0, ns0.RetrieveObjectScheduledTaskRequestType_Def) + ns0.RetrieveObjectScheduledTask_Dec.__bases__ = tuple(bases) + + ns0.RetrieveObjectScheduledTaskRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RetrieveObjectScheduledTask_Dec_Holder" + + class RetrieveObjectScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RetrieveObjectScheduledTaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RetrieveObjectScheduledTaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RetrieveObjectScheduledTaskResponse") + kw["aname"] = "_RetrieveObjectScheduledTaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "RetrieveObjectScheduledTaskResponse_Holder" + self.pyclass = Holder + + class OpenInventoryViewFolder_Dec(ElementDeclaration): + literal = "OpenInventoryViewFolder" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","OpenInventoryViewFolder") + kw["aname"] = "_OpenInventoryViewFolder" + if ns0.OpenInventoryViewFolderRequestType_Def not in ns0.OpenInventoryViewFolder_Dec.__bases__: + bases = list(ns0.OpenInventoryViewFolder_Dec.__bases__) + bases.insert(0, ns0.OpenInventoryViewFolderRequestType_Def) + ns0.OpenInventoryViewFolder_Dec.__bases__ = tuple(bases) + + ns0.OpenInventoryViewFolderRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "OpenInventoryViewFolder_Dec_Holder" + + class OpenInventoryViewFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "OpenInventoryViewFolderResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.OpenInventoryViewFolderResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","OpenInventoryViewFolderResponse") + kw["aname"] = "_OpenInventoryViewFolderResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "OpenInventoryViewFolderResponse_Holder" + self.pyclass = Holder + + class CloseInventoryViewFolder_Dec(ElementDeclaration): + literal = "CloseInventoryViewFolder" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CloseInventoryViewFolder") + kw["aname"] = "_CloseInventoryViewFolder" + if ns0.CloseInventoryViewFolderRequestType_Def not in ns0.CloseInventoryViewFolder_Dec.__bases__: + bases = list(ns0.CloseInventoryViewFolder_Dec.__bases__) + bases.insert(0, ns0.CloseInventoryViewFolderRequestType_Def) + ns0.CloseInventoryViewFolder_Dec.__bases__ = tuple(bases) + + ns0.CloseInventoryViewFolderRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CloseInventoryViewFolder_Dec_Holder" + + class CloseInventoryViewFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CloseInventoryViewFolderResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CloseInventoryViewFolderResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CloseInventoryViewFolderResponse") + kw["aname"] = "_CloseInventoryViewFolderResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "CloseInventoryViewFolderResponse_Holder" + self.pyclass = Holder + + class ModifyListView_Dec(ElementDeclaration): + literal = "ModifyListView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ModifyListView") + kw["aname"] = "_ModifyListView" + if ns0.ModifyListViewRequestType_Def not in ns0.ModifyListView_Dec.__bases__: + bases = list(ns0.ModifyListView_Dec.__bases__) + bases.insert(0, ns0.ModifyListViewRequestType_Def) + ns0.ModifyListView_Dec.__bases__ = tuple(bases) + + ns0.ModifyListViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ModifyListView_Dec_Holder" + + class ModifyListViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ModifyListViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ModifyListViewResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ModifyListViewResponse") + kw["aname"] = "_ModifyListViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ModifyListViewResponse_Holder" + self.pyclass = Holder + + class ResetListView_Dec(ElementDeclaration): + literal = "ResetListView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetListView") + kw["aname"] = "_ResetListView" + if ns0.ResetListViewRequestType_Def not in ns0.ResetListView_Dec.__bases__: + bases = list(ns0.ResetListView_Dec.__bases__) + bases.insert(0, ns0.ResetListViewRequestType_Def) + ns0.ResetListView_Dec.__bases__ = tuple(bases) + + ns0.ResetListViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetListView_Dec_Holder" + + class ResetListViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetListViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetListViewResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","ResetListViewResponse") + kw["aname"] = "_ResetListViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "ResetListViewResponse_Holder" + self.pyclass = Holder + + class ResetListViewFromView_Dec(ElementDeclaration): + literal = "ResetListViewFromView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","ResetListViewFromView") + kw["aname"] = "_ResetListViewFromView" + if ns0.ResetListViewFromViewRequestType_Def not in ns0.ResetListViewFromView_Dec.__bases__: + bases = list(ns0.ResetListViewFromView_Dec.__bases__) + bases.insert(0, ns0.ResetListViewFromViewRequestType_Def) + ns0.ResetListViewFromView_Dec.__bases__ = tuple(bases) + + ns0.ResetListViewFromViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "ResetListViewFromView_Dec_Holder" + + class ResetListViewFromViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "ResetListViewFromViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.ResetListViewFromViewResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","ResetListViewFromViewResponse") + kw["aname"] = "_ResetListViewFromViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "ResetListViewFromViewResponse_Holder" + self.pyclass = Holder + + class DestroyView_Dec(ElementDeclaration): + literal = "DestroyView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","DestroyView") + kw["aname"] = "_DestroyView" + if ns0.DestroyViewRequestType_Def not in ns0.DestroyView_Dec.__bases__: + bases = list(ns0.DestroyView_Dec.__bases__) + bases.insert(0, ns0.DestroyViewRequestType_Def) + ns0.DestroyView_Dec.__bases__ = tuple(bases) + + ns0.DestroyViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "DestroyView_Dec_Holder" + + class DestroyViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "DestroyViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.DestroyViewResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","DestroyViewResponse") + kw["aname"] = "_DestroyViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "DestroyViewResponse_Holder" + self.pyclass = Holder + + class CreateInventoryView_Dec(ElementDeclaration): + literal = "CreateInventoryView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateInventoryView") + kw["aname"] = "_CreateInventoryView" + if ns0.CreateInventoryViewRequestType_Def not in ns0.CreateInventoryView_Dec.__bases__: + bases = list(ns0.CreateInventoryView_Dec.__bases__) + bases.insert(0, ns0.CreateInventoryViewRequestType_Def) + ns0.CreateInventoryView_Dec.__bases__ = tuple(bases) + + ns0.CreateInventoryViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateInventoryView_Dec_Holder" + + class CreateInventoryViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateInventoryViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateInventoryViewResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateInventoryViewResponse") + kw["aname"] = "_CreateInventoryViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateInventoryViewResponse_Holder" + self.pyclass = Holder + + class CreateContainerView_Dec(ElementDeclaration): + literal = "CreateContainerView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateContainerView") + kw["aname"] = "_CreateContainerView" + if ns0.CreateContainerViewRequestType_Def not in ns0.CreateContainerView_Dec.__bases__: + bases = list(ns0.CreateContainerView_Dec.__bases__) + bases.insert(0, ns0.CreateContainerViewRequestType_Def) + ns0.CreateContainerView_Dec.__bases__ = tuple(bases) + + ns0.CreateContainerViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateContainerView_Dec_Holder" + + class CreateContainerViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateContainerViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateContainerViewResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateContainerViewResponse") + kw["aname"] = "_CreateContainerViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateContainerViewResponse_Holder" + self.pyclass = Holder + + class CreateListView_Dec(ElementDeclaration): + literal = "CreateListView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateListView") + kw["aname"] = "_CreateListView" + if ns0.CreateListViewRequestType_Def not in ns0.CreateListView_Dec.__bases__: + bases = list(ns0.CreateListView_Dec.__bases__) + bases.insert(0, ns0.CreateListViewRequestType_Def) + ns0.CreateListView_Dec.__bases__ = tuple(bases) + + ns0.CreateListViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateListView_Dec_Holder" + + class CreateListViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateListViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateListViewResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateListViewResponse") + kw["aname"] = "_CreateListViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateListViewResponse_Holder" + self.pyclass = Holder + + class CreateListViewFromView_Dec(ElementDeclaration): + literal = "CreateListViewFromView" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CreateListViewFromView") + kw["aname"] = "_CreateListViewFromView" + if ns0.CreateListViewFromViewRequestType_Def not in ns0.CreateListViewFromView_Dec.__bases__: + bases = list(ns0.CreateListViewFromView_Dec.__bases__) + bases.insert(0, ns0.CreateListViewFromViewRequestType_Def) + ns0.CreateListViewFromView_Dec.__bases__ = tuple(bases) + + ns0.CreateListViewFromViewRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CreateListViewFromView_Dec_Holder" + + class CreateListViewFromViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CreateListViewFromViewResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CreateListViewFromViewResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CreateListViewFromViewResponse") + kw["aname"] = "_CreateListViewFromViewResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CreateListViewFromViewResponse_Holder" + self.pyclass = Holder + + class RevertToSnapshot_Dec(ElementDeclaration): + literal = "RevertToSnapshot" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RevertToSnapshot") + kw["aname"] = "_RevertToSnapshot" + if ns0.RevertToSnapshotRequestType_Def not in ns0.RevertToSnapshot_Dec.__bases__: + bases = list(ns0.RevertToSnapshot_Dec.__bases__) + bases.insert(0, ns0.RevertToSnapshotRequestType_Def) + ns0.RevertToSnapshot_Dec.__bases__ = tuple(bases) + + ns0.RevertToSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RevertToSnapshot_Dec_Holder" + + class RevertToSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RevertToSnapshotResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RevertToSnapshotResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RevertToSnapshotResponse") + kw["aname"] = "_RevertToSnapshotResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RevertToSnapshotResponse_Holder" + self.pyclass = Holder + + class RevertToSnapshot_Task_Dec(ElementDeclaration): + literal = "RevertToSnapshot_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RevertToSnapshot_Task") + kw["aname"] = "_RevertToSnapshot_Task" + if ns0.RevertToSnapshotRequestType_Def not in ns0.RevertToSnapshot_Task_Dec.__bases__: + bases = list(ns0.RevertToSnapshot_Task_Dec.__bases__) + bases.insert(0, ns0.RevertToSnapshotRequestType_Def) + ns0.RevertToSnapshot_Task_Dec.__bases__ = tuple(bases) + + ns0.RevertToSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RevertToSnapshot_Task_Dec_Holder" + + class RevertToSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RevertToSnapshot_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RevertToSnapshot_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RevertToSnapshot_TaskResponse") + kw["aname"] = "_RevertToSnapshot_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RevertToSnapshot_TaskResponse_Holder" + self.pyclass = Holder + + class RemoveSnapshot_Dec(ElementDeclaration): + literal = "RemoveSnapshot" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveSnapshot") + kw["aname"] = "_RemoveSnapshot" + if ns0.RemoveSnapshotRequestType_Def not in ns0.RemoveSnapshot_Dec.__bases__: + bases = list(ns0.RemoveSnapshot_Dec.__bases__) + bases.insert(0, ns0.RemoveSnapshotRequestType_Def) + ns0.RemoveSnapshot_Dec.__bases__ = tuple(bases) + + ns0.RemoveSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveSnapshot_Dec_Holder" + + class RemoveSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveSnapshotResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveSnapshotResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RemoveSnapshotResponse") + kw["aname"] = "_RemoveSnapshotResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RemoveSnapshotResponse_Holder" + self.pyclass = Holder + + class RemoveSnapshot_Task_Dec(ElementDeclaration): + literal = "RemoveSnapshot_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RemoveSnapshot_Task") + kw["aname"] = "_RemoveSnapshot_Task" + if ns0.RemoveSnapshotRequestType_Def not in ns0.RemoveSnapshot_Task_Dec.__bases__: + bases = list(ns0.RemoveSnapshot_Task_Dec.__bases__) + bases.insert(0, ns0.RemoveSnapshotRequestType_Def) + ns0.RemoveSnapshot_Task_Dec.__bases__ = tuple(bases) + + ns0.RemoveSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RemoveSnapshot_Task_Dec_Holder" + + class RemoveSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RemoveSnapshot_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RemoveSnapshot_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","RemoveSnapshot_TaskResponse") + kw["aname"] = "_RemoveSnapshot_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "RemoveSnapshot_TaskResponse_Holder" + self.pyclass = Holder + + class RenameSnapshot_Dec(ElementDeclaration): + literal = "RenameSnapshot" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","RenameSnapshot") + kw["aname"] = "_RenameSnapshot" + if ns0.RenameSnapshotRequestType_Def not in ns0.RenameSnapshot_Dec.__bases__: + bases = list(ns0.RenameSnapshot_Dec.__bases__) + bases.insert(0, ns0.RenameSnapshotRequestType_Def) + ns0.RenameSnapshot_Dec.__bases__ = tuple(bases) + + ns0.RenameSnapshotRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "RenameSnapshot_Dec_Holder" + + class RenameSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "RenameSnapshotResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.RenameSnapshotResponse_Dec.schema + TClist = [] + kw["pname"] = ("urn:vim25","RenameSnapshotResponse") + kw["aname"] = "_RenameSnapshotResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + return + Holder.__name__ = "RenameSnapshotResponse_Holder" + self.pyclass = Holder + + class CheckCompatibility_Dec(ElementDeclaration): + literal = "CheckCompatibility" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckCompatibility") + kw["aname"] = "_CheckCompatibility" + if ns0.CheckCompatibilityRequestType_Def not in ns0.CheckCompatibility_Dec.__bases__: + bases = list(ns0.CheckCompatibility_Dec.__bases__) + bases.insert(0, ns0.CheckCompatibilityRequestType_Def) + ns0.CheckCompatibility_Dec.__bases__ = tuple(bases) + + ns0.CheckCompatibilityRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckCompatibility_Dec_Holder" + + class CheckCompatibilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckCompatibilityResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckCompatibilityResponse_Dec.schema + TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckCompatibilityResponse") + kw["aname"] = "_CheckCompatibilityResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "CheckCompatibilityResponse_Holder" + self.pyclass = Holder + + class CheckCompatibility_Task_Dec(ElementDeclaration): + literal = "CheckCompatibility_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckCompatibility_Task") + kw["aname"] = "_CheckCompatibility_Task" + if ns0.CheckCompatibilityRequestType_Def not in ns0.CheckCompatibility_Task_Dec.__bases__: + bases = list(ns0.CheckCompatibility_Task_Dec.__bases__) + bases.insert(0, ns0.CheckCompatibilityRequestType_Def) + ns0.CheckCompatibility_Task_Dec.__bases__ = tuple(bases) + + ns0.CheckCompatibilityRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckCompatibility_Task_Dec_Holder" + + class CheckCompatibility_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckCompatibility_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckCompatibility_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckCompatibility_TaskResponse") + kw["aname"] = "_CheckCompatibility_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CheckCompatibility_TaskResponse_Holder" + self.pyclass = Holder + + class QueryVMotionCompatibilityEx_Dec(ElementDeclaration): + literal = "QueryVMotionCompatibilityEx" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityEx") + kw["aname"] = "_QueryVMotionCompatibilityEx" + if ns0.QueryVMotionCompatibilityExRequestType_Def not in ns0.QueryVMotionCompatibilityEx_Dec.__bases__: + bases = list(ns0.QueryVMotionCompatibilityEx_Dec.__bases__) + bases.insert(0, ns0.QueryVMotionCompatibilityExRequestType_Def) + ns0.QueryVMotionCompatibilityEx_Dec.__bases__ = tuple(bases) + + ns0.QueryVMotionCompatibilityExRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVMotionCompatibilityEx_Dec_Holder" + + class QueryVMotionCompatibilityExResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVMotionCompatibilityExResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVMotionCompatibilityExResponse_Dec.schema + TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityExResponse") + kw["aname"] = "_QueryVMotionCompatibilityExResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "QueryVMotionCompatibilityExResponse_Holder" + self.pyclass = Holder + + class QueryVMotionCompatibilityEx_Task_Dec(ElementDeclaration): + literal = "QueryVMotionCompatibilityEx_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityEx_Task") + kw["aname"] = "_QueryVMotionCompatibilityEx_Task" + if ns0.QueryVMotionCompatibilityExRequestType_Def not in ns0.QueryVMotionCompatibilityEx_Task_Dec.__bases__: + bases = list(ns0.QueryVMotionCompatibilityEx_Task_Dec.__bases__) + bases.insert(0, ns0.QueryVMotionCompatibilityExRequestType_Def) + ns0.QueryVMotionCompatibilityEx_Task_Dec.__bases__ = tuple(bases) + + ns0.QueryVMotionCompatibilityExRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "QueryVMotionCompatibilityEx_Task_Dec_Holder" + + class QueryVMotionCompatibilityEx_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "QueryVMotionCompatibilityEx_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.QueryVMotionCompatibilityEx_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityEx_TaskResponse") + kw["aname"] = "_QueryVMotionCompatibilityEx_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "QueryVMotionCompatibilityEx_TaskResponse_Holder" + self.pyclass = Holder + + class CheckMigrate_Dec(ElementDeclaration): + literal = "CheckMigrate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckMigrate") + kw["aname"] = "_CheckMigrate" + if ns0.CheckMigrateRequestType_Def not in ns0.CheckMigrate_Dec.__bases__: + bases = list(ns0.CheckMigrate_Dec.__bases__) + bases.insert(0, ns0.CheckMigrateRequestType_Def) + ns0.CheckMigrate_Dec.__bases__ = tuple(bases) + + ns0.CheckMigrateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckMigrate_Dec_Holder" + + class CheckMigrateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckMigrateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckMigrateResponse_Dec.schema + TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckMigrateResponse") + kw["aname"] = "_CheckMigrateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "CheckMigrateResponse_Holder" + self.pyclass = Holder + + class CheckMigrate_Task_Dec(ElementDeclaration): + literal = "CheckMigrate_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckMigrate_Task") + kw["aname"] = "_CheckMigrate_Task" + if ns0.CheckMigrateRequestType_Def not in ns0.CheckMigrate_Task_Dec.__bases__: + bases = list(ns0.CheckMigrate_Task_Dec.__bases__) + bases.insert(0, ns0.CheckMigrateRequestType_Def) + ns0.CheckMigrate_Task_Dec.__bases__ = tuple(bases) + + ns0.CheckMigrateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckMigrate_Task_Dec_Holder" + + class CheckMigrate_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckMigrate_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckMigrate_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckMigrate_TaskResponse") + kw["aname"] = "_CheckMigrate_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CheckMigrate_TaskResponse_Holder" + self.pyclass = Holder + + class CheckRelocate_Dec(ElementDeclaration): + literal = "CheckRelocate" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckRelocate") + kw["aname"] = "_CheckRelocate" + if ns0.CheckRelocateRequestType_Def not in ns0.CheckRelocate_Dec.__bases__: + bases = list(ns0.CheckRelocate_Dec.__bases__) + bases.insert(0, ns0.CheckRelocateRequestType_Def) + ns0.CheckRelocate_Dec.__bases__ = tuple(bases) + + ns0.CheckRelocateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckRelocate_Dec_Holder" + + class CheckRelocateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckRelocateResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckRelocateResponse_Dec.schema + TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckRelocateResponse") + kw["aname"] = "_CheckRelocateResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = [] + return + Holder.__name__ = "CheckRelocateResponse_Holder" + self.pyclass = Holder + + class CheckRelocate_Task_Dec(ElementDeclaration): + literal = "CheckRelocate_Task" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","CheckRelocate_Task") + kw["aname"] = "_CheckRelocate_Task" + if ns0.CheckRelocateRequestType_Def not in ns0.CheckRelocate_Task_Dec.__bases__: + bases = list(ns0.CheckRelocate_Task_Dec.__bases__) + bases.insert(0, ns0.CheckRelocateRequestType_Def) + ns0.CheckRelocate_Task_Dec.__bases__ = tuple(bases) + + ns0.CheckRelocateRequestType_Def.__init__(self, **kw) + if self.pyclass is not None: self.pyclass.__name__ = "CheckRelocate_Task_Dec_Holder" + + class CheckRelocate_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): + literal = "CheckRelocate_TaskResponse" + schema = "urn:vim25" + def __init__(self, **kw): + ns = ns0.CheckRelocate_TaskResponse_Dec.schema + TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] + kw["pname"] = ("urn:vim25","CheckRelocate_TaskResponse") + kw["aname"] = "_CheckRelocate_TaskResponse" + self.attribute_typecode_dict = {} + ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) + class Holder: + __metaclass__ = pyclass_type + typecode = self + def __init__(self): + # pyclass + self._returnval = None + return + Holder.__name__ = "CheckRelocate_TaskResponse_Holder" + self.pyclass = Holder + + class versionURI_Dec(ZSI.TC.String, ElementDeclaration): + literal = "versionURI" + schema = "urn:vim25" + def __init__(self, **kw): + kw["pname"] = ("urn:vim25","versionURI") + kw["aname"] = "_versionURI" + class IHolder(str): typecode=self + kw["pyclass"] = IHolder + IHolder.__name__ = "_versionURI_immutable_holder" + ZSI.TC.String.__init__(self, **kw) + +# end class ns0 (tns: urn:vim25) diff --git a/nova/virt/vmwareapi/__init__.py b/nova/virt/vmwareapi/__init__.py new file mode 100644 index 000000000..e9c06d96a --- /dev/null +++ b/nova/virt/vmwareapi/__init__.py @@ -0,0 +1,16 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py new file mode 100644 index 000000000..48ea4debf --- /dev/null +++ b/nova/virt/vmwareapi/io_util.py @@ -0,0 +1,168 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" + Reads a chunk from input file and writes the same to the output file till + it reaches the transferable size. +""" + +from Queue import Queue, Full, Empty +from threading import Thread +import time +import traceback + + +class ThreadSafePipe(Queue): + """ + ThreadSafePipe class queue's the chunk data. + """ + + def __init__(self, max_size=None): + """ + Initializes the queue + """ + Queue.__init__(self, max_size) + self.eof = False + + def write(self, data): + """ + Writes the chunk data to the queue. + """ + self.put(data, block=False) + + def read(self): + """ + Retrieves the chunk data from the queue. + """ + return self.get(block=False) + + def set_eof(self, eof): + """ + Sets EOF to mark reading of input file finishes. + """ + self.eof = eof + + def get_eof(self): + """ + Returns whether EOF reached. + """ + return self.eof + + +class IOThread(Thread): + """ + IOThread reads chunks from input file and pipes it to output file till it + reaches the transferable size + """ + + def __init__(self, input_file, output_file, chunk_size, transfer_size): + """ + Initialize the thread. + inputFile and outputFile should be file like objects. + """ + Thread.__init__(self) + self.input_file = input_file + self.output_file = output_file + self.chunk_size = chunk_size + self.transfer_size = transfer_size + self.read_size = 0 + self._done = False + self._stop_transfer = False + self._error = False + self._exception = None + + def run(self): + """ + Pipes the input chunk read to the output file till it reaches + transferable size + """ + try: + if self.transfer_size and self.transfer_size <= self.chunk_size: + self.chunk_size = self.transfer_size + data = None + while True: + if not self.transfer_size is None: + if self.read_size >= self.transfer_size: + break + if self._stop_transfer: + break + try: + #read chunk only if no previous chunk + if data is None: + if isinstance(self.input_file, ThreadSafePipe): + data = self.input_file.read() + else: + data = self.input_file.read(self.chunk_size) + if not data: + # no more data to read + break + if data: + # write chunk + self.output_file.write(data) + self.read_size = self.read_size + len(data) + # clear chunk since write is a success + data = None + except Empty: + # Pipe side is empty - safe to check for eof signal + if self.input_file.get_eof(): + # no more data in read + break + #Restrict tight loop + time.sleep(.01) + except Full: + # Pipe full while writing to pipe - safe to retry since + #chunk is preserved + #Restrict tight loop + time.sleep(.01) + if isinstance(self.output_file, ThreadSafePipe): + # If this is the reader thread, send eof signal + self.output_file.set_eof(True) + + if not self.transfer_size is None: + if self.read_size < self.transfer_size: + raise IOError("Not enough data (%d of %d bytes)" \ + % (self.read_size, self.transfer_size)) + + except: + self._error = True + self._exception = str(traceback.format_exc()) + self._done = True + + def stop_io_transfer(self): + """ + Set the stop flag to true, which causes the thread to stop safely. + """ + self._stop_transfer = True + self.join() + + def get_error(self): + """ + Returns the error string. + """ + return self._error + + def get_exception(self): + """ + Returns the traceback exception string. + """ + return self._exception + + def is_done(self): + """ + Checks whether transfer is complete. + """ + return self._done diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py new file mode 100644 index 000000000..c3eeb0566 --- /dev/null +++ b/nova/virt/vmwareapi/read_write_util.py @@ -0,0 +1,381 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import httplib +import json +import logging +import os +import urllib +import urllib2 +import urlparse + +from nova import flags +from nova import utils +from nova.auth.manager import AuthManager + +FLAGS = flags.FLAGS + +READ_CHUNKSIZE = 2 * 1024 * 1024 + +USER_AGENT = "OpenStack-ESX-Adapter" + +LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util") + + +class ImageServiceFile: + """ + The base image service Class + """ + + def __init__(self, file_handle): + """ + Initialize the file handle. + """ + self.eof = False + self.file_handle = file_handle + + def write(self, data): + """ + Write data to the file + """ + raise NotImplementedError + + def read(self, chunk_size=READ_CHUNKSIZE): + """ + Read a chunk of data from the file + """ + raise NotImplementedError + + def get_size(self): + """ + Get the size of the file whose data is to be read + """ + raise NotImplementedError + + def set_eof(self, eof): + """ + Set the end of file marker. + """ + self.eof = eof + + def get_eof(self): + """ + Check if the file end has been reached or not. + """ + return self.eof + + def close(self): + """ + Close the file handle. + """ + try: + self.file_handle.close() + except: + pass + + def get_image_properties(self): + """ + Get the image properties + """ + raise NotImplementedError + + def __del__(self): + """ + Destructor. Close the file handle if the same has been forgotten. + """ + self.close() + + +class GlanceHTTPWriteFile(ImageServiceFile): + """ + Glance file write handler Class + """ + + def __init__(self, host, port, image_id, file_size, os_type, adapter_type, + version=1, scheme="http"): + """ + Initialize with the glance host specifics. + """ + base_url = "%s://%s:%s/images/%s" % (scheme, host, port, image_id) + (scheme, netloc, path, params, query, fragment) = \ + urlparse.urlparse(base_url) + if scheme == "http": + conn = httplib.HTTPConnection(netloc) + elif scheme == "https": + conn = httplib.HTTPSConnection(netloc) + conn.putrequest("PUT", path) + conn.putheader("User-Agent", USER_AGENT) + conn.putheader("Content-Length", file_size) + conn.putheader("Content-Type", "application/octet-stream") + conn.putheader("x-image-meta-store", "file") + conn.putheader("x-image-meta-is_public", "True") + conn.putheader("x-image-meta-type", "raw") + conn.putheader("x-image-meta-size", file_size) + conn.putheader("x-image-meta-property-kernel_id", "") + conn.putheader("x-image-meta-property-ramdisk_id", "") + conn.putheader("x-image-meta-property-vmware_ostype", os_type) + conn.putheader("x-image-meta-property-vmware_adaptertype", + adapter_type) + conn.putheader("x-image-meta-property-vmware_image_version", version) + conn.endheaders() + ImageServiceFile.__init__(self, conn) + + def write(self, data): + """ + Write data to the file + """ + self.file_handle.send(data) + + +class GlanceHTTPReadFile(ImageServiceFile): + """ + Glance file read handler Class + """ + + def __init__(self, host, port, image_id, scheme="http"): + """ + Initialize with the glance host specifics. + """ + base_url = "%s://%s:%s/images/%s" % (scheme, host, port, + urllib.pathname2url(image_id)) + headers = {'User-Agent': USER_AGENT} + request = urllib2.Request(base_url, None, headers) + conn = urllib2.urlopen(request) + ImageServiceFile.__init__(self, conn) + + def read(self, chunk_size=READ_CHUNKSIZE): + """ + Read a chunk of data. + """ + return self.file_handle.read(chunk_size) + + def get_size(self): + """ + Get the size of the file to be read. + """ + return self.file_handle.headers.get("X-Image-Meta-Size", -1) + + def get_image_properties(self): + """ + Get the image properties like say OS Type and the Adapter Type + """ + return {"vmware_ostype": + self.file_handle.headers.get( + "X-Image-Meta-Property-Vmware_ostype"), + "vmware_adaptertype": + self.file_handle.headers.get( + "X-Image-Meta-Property-Vmware_adaptertype"), + "vmware_image_version": + self.file_handle.headers.get( + "X-Image-Meta-Property-Vmware_image_version")} + + +class FakeFileRead(ImageServiceFile): + """ + Local file read handler class + """ + + def __init__(self, path): + """ + Initialize the file path + """ + self.path = path + file_handle = open(path, "rb") + ImageServiceFile.__init__(self, file_handle) + + def get_size(self): + """ + Get size of the file to be read + """ + return os.path.getsize(os.path.abspath(self.path)) + + def read(self, chunk_size=READ_CHUNKSIZE): + """ + Read a chunk of data + """ + return self.file_handle.read(chunk_size) + + def get_image_properties(self): + """ + Get the image properties like say OS Type and the Adapter Type + """ + return {"vmware_ostype": "otherGuest", + "vmware_adaptertype": "lsiLogic", + "vmware_image_version": "1"} + + +class FakeFileWrite(ImageServiceFile): + """ + Local file write handler Class + """ + + def __init__(self, path): + """ + Initialize the file path. + """ + file_handle = open(path, "wb") + ImageServiceFile.__init__(self, file_handle) + + def write(self, data): + """ + Write data to the file. + """ + self.file_handle.write(data) + + +class VMwareHTTPFile(object): + """ + Base Class for HTTP file. + """ + + def __init__(self, file_handle): + """ + Intialize the file handle. + """ + self.eof = False + self.file_handle = file_handle + + def set_eof(self, eof): + """ + Set the end of file marker. + """ + self.eof = eof + + def get_eof(self): + """ + Check if the end of file has been reached. + """ + return self.eof + + def close(self): + """ + Close the file handle. + """ + try: + self.file_handle.close() + except: + pass + + def __del__(self): + """ + Destructor. Close the file handle if the same has been forgotten. + """ + self.close() + + def _build_vim_cookie_headers(self, vim_cookies): + """ + Build ESX host session cookie headers. + """ + cookie = str(vim_cookies).split(":")[1].strip() + cookie = cookie[:cookie.find(';')] + return cookie + + def write(self, data): + """ + Write data to the file. + """ + raise NotImplementedError + + def read(self, chunk_size=READ_CHUNKSIZE): + """ + Read a chunk of data. + """ + raise NotImplementedError + + def get_size(self): + """ + Get size of the file to be read. + """ + raise NotImplementedError + + +class VMWareHTTPWriteFile(VMwareHTTPFile): + """ + VMWare file write handler Class + """ + + def __init__(self, host, data_center_name, datastore_name, cookies, + file_path, file_size, scheme="https"): + """ + Initialize the file specifics. + """ + base_url = "%s://%s/folder/%s" % (scheme, host, file_path) + param_list = {"dcPath": data_center_name, "dsName": datastore_name} + base_url = base_url + "?" + urllib.urlencode(param_list) + (scheme, netloc, path, params, query, fragment) = \ + urlparse.urlparse(base_url) + if scheme == "http": + conn = httplib.HTTPConnection(netloc) + elif scheme == "https": + conn = httplib.HTTPSConnection(netloc) + conn.putrequest("PUT", path + "?" + query) + conn.putheader("User-Agent", USER_AGENT) + conn.putheader("Content-Length", file_size) + conn.putheader("Cookie", self._build_vim_cookie_headers(cookies)) + conn.endheaders() + self.conn = conn + VMwareHTTPFile.__init__(self, conn) + + def write(self, data): + """ + Write to the file. + """ + self.file_handle.send(data) + + def close(self): + """ + Get the response and close the connection + """ + try: + self.conn.getresponse() + except Exception, excep: + LOG.debug("Exception during close of connection in " + "VMWareHTTpWrite. Exception is %s" % excep) + super(VMWareHTTPWriteFile, self).close() + + +class VmWareHTTPReadFile(VMwareHTTPFile): + """ + VMWare file read handler Class + """ + + def __init__(self, host, data_center_name, datastore_name, cookies, + file_path, scheme="https"): + """ + Initialize the file specifics. + """ + base_url = "%s://%s/folder/%s" % (scheme, host, + urllib.pathname2url(file_path)) + param_list = {"dcPath": data_center_name, "dsName": datastore_name} + base_url = base_url + "?" + urllib.urlencode(param_list) + headers = {'User-Agent': USER_AGENT, + 'Cookie': self._build_vim_cookie_headers(cookies)} + request = urllib2.Request(base_url, None, headers) + conn = urllib2.urlopen(request) + VMwareHTTPFile.__init__(self, conn) + + def read(self, chunk_size=READ_CHUNKSIZE): + """ + Read a chunk of data. + """ + return self.file_handle.read(chunk_size) + + def get_size(self): + """ + Get size of the file to be read. + """ + return self.file_handle.headers.get("Content-Length", -1) diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py new file mode 100644 index 000000000..03439a049 --- /dev/null +++ b/nova/virt/vmwareapi/vim.py @@ -0,0 +1,195 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import ZSI +import httplib + +from nova.virt.vmwareapi import VimService_services + +RESP_NOT_XML_ERROR = 'Response is "text/html", not "text/xml' +CONN_ABORT_ERROR = 'Software caused connection abort' +ADDRESS_IN_USE_ERROR = 'Address already in use' + + +class VimException(Exception): + """ + The VIM Exception class + """ + + def __init__(self, exception_summary, excep): + """ + Initializer + """ + Exception.__init__(self) + self.exception_summary = exception_summary + self.exception_obj = excep + + def __str__(self): + """ + The informal string representation of the object + """ + return self.exception_summary + str(self.exception_obj) + + +class SessionOverLoadException(VimException): + """ + Session Overload Exception + """ + pass + + +class SessionFaultyException(VimException): + """ + Session Faulty Exception + """ + pass + + +class VimAttributeError(VimException): + """ + Attribute Error + """ + pass + + +class Vim: + """ + The VIM Object + """ + + def __init__(self, + protocol="https", + host="localhost", + trace=None): + """ + Initializer + + protocol: http or https + host : ESX IPAddress[:port] or ESX Hostname[:port] + trace : File handle (eg. sys.stdout, sys.stderr , + open("file.txt",w), Use it only for debugging + SOAP Communication + Creates the necessary Communication interfaces, Gets the + ServiceContent for initiating SOAP transactions + """ + self._protocol = protocol + self._host_name = host + service_locator = VimService_services.VimServiceLocator() + connect_string = "%s://%s/sdk" % (self._protocol, self._host_name) + if trace == None: + self.proxy = \ + service_locator.getVimPortType(url=connect_string) + else: + self.proxy = service_locator.getVimPortType(url=connect_string, + tracefile=trace) + self._service_content = \ + self.RetrieveServiceContent("ServiceInstance") + + def get_service_content(self): + """ + Gets the service content object + """ + return self._service_content + + def __getattr__(self, attr_name): + """ + Makes the API calls and gets the result + """ + try: + return object.__getattr__(self, attr_name) + except AttributeError: + + def vim_request_handler(managed_object, **kwargs): + """ + managed_object : Managed Object Reference or Managed + Object Name + **kw : Keyword arguments of the call + """ + #Dynamic handler for VI SDK Calls + response = None + try: + request_msg = \ + self._request_message_builder(attr_name, + managed_object, **kwargs) + request = getattr(self.proxy, attr_name) + response = request(request_msg) + if response == None: + return None + else: + try: + return getattr(response, "_returnval") + except AttributeError, excep: + return None + except AttributeError, excep: + raise VimAttributeError("No such SOAP method '%s'" + " provided by VI SDK" % (attr_name), excep) + except ZSI.FaultException, excep: + raise SessionFaultyException(" in" + " %s:" % (attr_name), excep) + except ZSI.EvaluateException, excep: + raise SessionFaultyException(" in" + " %s:" % (attr_name), excep) + except (httplib.CannotSendRequest, + httplib.ResponseNotReady, + httplib.CannotSendHeader), excep: + raise SessionOverLoadException("httplib errror in" + " %s: " % (attr_name), excep) + except Exception, excep: + # Socket errors which need special handling for they + # might be caused by ESX API call overload + if (str(excep).find(ADDRESS_IN_USE_ERROR) != -1 or + str(excep).find(CONN_ABORT_ERROR)): + raise SessionOverLoadException("Socket error in" + " %s: " % (attr_name), excep) + # Type error that needs special handling for it might be + # caused by ESX host API call overload + elif str(excep).find(RESP_NOT_XML_ERROR) != -1: + raise SessionOverLoadException("Type error in " + " %s: " % (attr_name), excep) + else: + raise VimException( + "Exception in %s " % (attr_name), excep) + return vim_request_handler + + def _request_message_builder(self, method_name, managed_object, **kwargs): + """ + Builds the Request Message + """ + #Request Message Builder + request_msg = getattr(VimService_services, \ + method_name + "RequestMsg")() + element = request_msg.new__this(managed_object) + if type(managed_object) == type(""): + element.set_attribute_type(managed_object) + else: + element.set_attribute_type(managed_object.get_attribute_type()) + request_msg.set_element__this(element) + for key in kwargs: + getattr(request_msg, "set_element_" + key)(kwargs[key]) + return request_msg + + def __repr__(self): + """ + The official string representation + """ + return "VIM Object" + + def __str__(self): + """ + The informal string representation + """ + return "VIM Object" diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py new file mode 100644 index 000000000..8596a1004 --- /dev/null +++ b/nova/virt/vmwareapi/vim_util.py @@ -0,0 +1,291 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +The VMware API utility module +""" +from nova.virt.vmwareapi.VimService_services_types import ns0 + +MAX_CLONE_RETRIES = 1 + + +def build_recursive_traversal_spec(): + """ + Builds the Traversal Spec + """ + #Traversal through "hostFolder" branch + visit_folders_select_spec = ns0.SelectionSpec_Def("visitFolders").pyclass() + visit_folders_select_spec.set_element_name("visitFolders") + select_set = [visit_folders_select_spec] + dc_to_hf = ns0.TraversalSpec_Def("dc_to_hf").pyclass() + dc_to_hf.set_element_name("dc_to_hf") + dc_to_hf.set_element_type("Datacenter") + dc_to_hf.set_element_path("hostFolder") + dc_to_hf.set_element_skip(False) + dc_to_hf.set_element_selectSet(select_set) + + #Traversal through "vmFolder" branch + visit_folders_select_spec = ns0.SelectionSpec_Def("visitFolders").pyclass() + visit_folders_select_spec.set_element_name("visitFolders") + select_set = [visit_folders_select_spec] + dc_to_vmf = ns0.TraversalSpec_Def("dc_to_vmf").pyclass() + dc_to_vmf.set_element_name("dc_to_vmf") + dc_to_vmf.set_element_type("Datacenter") + dc_to_vmf.set_element_path("vmFolder") + dc_to_vmf.set_element_skip(False) + dc_to_vmf.set_element_selectSet(select_set) + + #Traversal to the DataStore from the DataCenter + visit_folders_select_spec = \ + ns0.SelectionSpec_Def("traverseChild").pyclass() + visit_folders_select_spec.set_element_name("traverseChild") + select_set = [visit_folders_select_spec] + dc_to_ds = ns0.TraversalSpec_Def("dc_to_ds").pyclass() + dc_to_ds.set_element_name("dc_to_ds") + dc_to_ds.set_element_type("Datacenter") + dc_to_ds.set_element_path("datastore") + dc_to_ds.set_element_skip(False) + dc_to_ds.set_element_selectSet(select_set) + + #Traversal through "vm" branch + visit_folders_select_spec = \ + ns0.SelectionSpec_Def("visitFolders").pyclass() + visit_folders_select_spec.set_element_name("visitFolders") + select_set = [visit_folders_select_spec] + h_to_vm = ns0.TraversalSpec_Def("h_to_vm").pyclass() + h_to_vm.set_element_name("h_to_vm") + h_to_vm.set_element_type("HostSystem") + h_to_vm.set_element_path("vm") + h_to_vm.set_element_skip(False) + h_to_vm.set_element_selectSet(select_set) + + #Traversal through "host" branch + cr_to_h = ns0.TraversalSpec_Def("cr_to_h").pyclass() + cr_to_h.set_element_name("cr_to_h") + cr_to_h.set_element_type("ComputeResource") + cr_to_h.set_element_path("host") + cr_to_h.set_element_skip(False) + cr_to_h.set_element_selectSet([]) + + cr_to_ds = ns0.TraversalSpec_Def("cr_to_ds").pyclass() + cr_to_ds.set_element_name("cr_to_ds") + cr_to_ds.set_element_type("ComputeResource") + cr_to_ds.set_element_path("datastore") + cr_to_ds.set_element_skip(False) + + #Traversal through "resourcePool" branch + rp_to_rp_select_spec = ns0.SelectionSpec_Def("rp_to_rp").pyclass() + rp_to_rp_select_spec.set_element_name("rp_to_rp") + rp_to_vm_select_spec = ns0.SelectionSpec_Def("rp_to_vm").pyclass() + rp_to_vm_select_spec.set_element_name("rp_to_vm") + select_set = [rp_to_rp_select_spec, rp_to_vm_select_spec] + cr_to_rp = ns0.TraversalSpec_Def("cr_to_rp").pyclass() + cr_to_rp.set_element_name("cr_to_rp") + cr_to_rp.set_element_type("ComputeResource") + cr_to_rp.set_element_path("resourcePool") + cr_to_rp.set_element_skip(False) + cr_to_rp.set_element_selectSet(select_set) + + #Traversal through all ResourcePools + rp_to_rp_select_spec = ns0.SelectionSpec_Def("rp_to_rp").pyclass() + rp_to_rp_select_spec.set_element_name("rp_to_rp") + rp_to_vm_select_spec = ns0.SelectionSpec_Def("rp_to_vm").pyclass() + rp_to_vm_select_spec.set_element_name("rp_to_vm") + select_set = [rp_to_rp_select_spec, rp_to_vm_select_spec] + rp_to_rp = ns0.TraversalSpec_Def("rp_to_rp").pyclass() + rp_to_rp.set_element_name("rp_to_rp") + rp_to_rp.set_element_type("ResourcePool") + rp_to_rp.set_element_path("resourcePool") + rp_to_rp.set_element_skip(False) + rp_to_rp.set_element_selectSet(select_set) + + #Traversal through ResourcePools vm folders + rp_to_rp_select_spec = ns0.SelectionSpec_Def("rp_to_rp").pyclass() + rp_to_rp_select_spec.set_element_name("rp_to_rp") + rp_to_vm_select_spec = ns0.SelectionSpec_Def("rp_to_vm").pyclass() + rp_to_vm_select_spec.set_element_name("rp_to_vm") + select_set = [rp_to_rp_select_spec, rp_to_vm_select_spec] + rp_to_vm = ns0.TraversalSpec_Def("rp_to_vm").pyclass() + rp_to_vm.set_element_name("rp_to_vm") + rp_to_vm.set_element_type("ResourcePool") + rp_to_vm.set_element_path("vm") + rp_to_vm.set_element_skip(False) + rp_to_vm.set_element_selectSet(select_set) + + #Include all Traversals and Recurse into them + visit_folders_select_spec = \ + ns0.SelectionSpec_Def("visitFolders").pyclass() + visit_folders_select_spec.set_element_name("visitFolders") + select_set = [visit_folders_select_spec, dc_to_hf, dc_to_vmf, + cr_to_ds, cr_to_h, cr_to_rp, rp_to_rp, h_to_vm, rp_to_vm] + traversal_spec = ns0.TraversalSpec_Def("visitFolders").pyclass() + traversal_spec.set_element_name("visitFolders") + traversal_spec.set_element_type("Folder") + traversal_spec.set_element_path("childEntity") + traversal_spec.set_element_skip(False) + traversal_spec.set_element_selectSet(select_set) + return traversal_spec + + +def build_property_spec(type="VirtualMachine", properties_to_collect=["name"], + all_properties=False): + """ + Builds the Property Spec + """ + property_spec = ns0.PropertySpec_Def("propertySpec").pyclass() + property_spec.set_element_type(type) + property_spec.set_element_all(all_properties) + property_spec.set_element_pathSet(properties_to_collect) + return property_spec + + +def build_object_spec(root_folder, traversal_specs): + """ + Builds the object Spec + """ + object_spec = ns0.ObjectSpec_Def("ObjectSpec").pyclass() + object_spec.set_element_obj(root_folder) + object_spec.set_element_skip(False) + object_spec.set_element_selectSet(traversal_specs) + return object_spec + + +def build_property_filter_spec(property_specs, object_specs): + """ + Builds the Property Filter Spec + """ + property_filter_spec = \ + ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() + property_filter_spec.set_element_propSet(property_specs) + property_filter_spec.set_element_objectSet(object_specs) + return property_filter_spec + + +def get_object_properties(vim, collector, mobj, type, properties): + """ + Gets the properties of the Managed object specified + """ + if mobj is None: + return None + usecoll = collector + if usecoll is None: + usecoll = vim.get_service_content().PropertyCollector + property_filter_spec = \ + ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() + property_filter_spec._propSet = \ + [ns0.PropertySpec_Def("PropertySpec").pyclass()] + property_filter_spec.PropSet[0]._all = \ + (properties == None or len(properties) == 0) + property_filter_spec.PropSet[0]._type = type + property_filter_spec.PropSet[0]._pathSet = properties + + property_filter_spec._objectSet = \ + [ns0.ObjectSpec_Def("ObjectSpec").pyclass()] + property_filter_spec.ObjectSet[0]._obj = mobj + property_filter_spec.ObjectSet[0]._skip = False + return vim.RetrieveProperties(usecoll, specSet=[property_filter_spec]) + + +def get_dynamic_property(vim, mobj, type, property_name): + """ + Gets a particular property of the Managed Object + """ + obj_content = \ + get_object_properties(vim, None, mobj, type, [property_name]) + property_value = None + if obj_content: + dynamic_property = obj_content[0].PropSet + if dynamic_property: + property_value = dynamic_property[0].Val + return property_value + + +def get_objects(vim, type, properties_to_collect=["name"], all=False): + """ + Gets the list of objects of the type specified + """ + object_spec = build_object_spec(vim.get_service_content().RootFolder, + [build_recursive_traversal_spec()]) + property_spec = build_property_spec(type=type, + properties_to_collect=properties_to_collect, + all_properties=all) + property_filter_spec = build_property_filter_spec([property_spec], + [object_spec]) + return vim.RetrieveProperties(vim.get_service_content().PropertyCollector, + specSet=[property_filter_spec]) + + +def get_traversal_spec(type, path, name="traversalSpec"): + """ + Builds the traversal spec object + """ + t_spec = ns0.TraversalSpec_Def(name).pyclass() + t_spec._name = name + t_spec._type = type + t_spec._path = path + t_spec._skip = False + return t_spec + + +def get_prop_spec(type, properties): + """ + Builds the Property Spec Object + """ + prop_spec = ns0.PropertySpec_Def("PropertySpec").pyclass() + prop_spec._type = type + prop_spec._pathSet = properties + return prop_spec + + +def get_obj_spec(obj, select_set=None): + """ + Builds the Object Spec object + """ + obj_spec = ns0.ObjectSpec_Def("ObjectSpec").pyclass() + obj_spec._obj = obj + obj_spec._skip = False + if select_set is not None: + obj_spec._selectSet = select_set + return obj_spec + + +def get_prop_filter_spec(obj_spec, prop_spec): + """ + Builds the Property Filter Spec Object + """ + prop_filter_spec = \ + ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() + prop_filter_spec._propSet = prop_spec + prop_filter_spec._objectSet = obj_spec + return prop_filter_spec + + +def get_properites_for_a_collection_of_objects(vim, type, + obj_list, properties): + """ + Gets the list of properties for the collection of + objects of the type specified + """ + if len(obj_list) == 0: + return [] + prop_spec = get_prop_spec(type, properties) + lst_obj_specs = [] + for obj in obj_list: + lst_obj_specs.append(get_obj_spec(obj)) + prop_filter_spec = get_prop_filter_spec(lst_obj_specs, [prop_spec]) + return vim.RetrieveProperties(vim.get_service_content().PropertyCollector, + specSet=[prop_filter_spec]) diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py new file mode 100644 index 000000000..603537278 --- /dev/null +++ b/nova/virt/vmwareapi/vm_util.py @@ -0,0 +1,321 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from nova.virt.vmwareapi.VimService_services_types import ns0 + + +def build_datastore_path(datastore_name, path): + """ + Build the datastore compliant path + """ + return "[%s] %s" % (datastore_name, path) + + +def split_datastore_path(datastore_path): + """ + Split the VMWare style datastore path to get the Datastore name and the + entity path + """ + spl = datastore_path.split('[', 1)[1].split(']', 1) + path = "" + if len(spl) == 1: + datastore_url = spl[0] + else: + datastore_url, path = spl + return datastore_url, path.strip() + + +def get_vm_create_spec(instance, data_store_name, network_name="vmnet0", + os_type="otherGuest"): + """ + Builds the VM Create spec + """ + config_spec = ns0.VirtualMachineConfigSpec_Def( + "VirtualMachineConfigSpec").pyclass() + + config_spec._name = instance.name + config_spec._guestId = os_type + + vm_file_info = ns0.VirtualMachineFileInfo_Def( + "VirtualMachineFileInfo").pyclass() + vm_file_info._vmPathName = "[" + data_store_name + "]" + config_spec._files = vm_file_info + + tools_info = ns0.ToolsConfigInfo_Def("ToolsConfigInfo") + tools_info._afterPowerOn = True + tools_info._afterResume = True + tools_info._beforeGuestStandby = True + tools_info._bbeforeGuestShutdown = True + tools_info._beforeGuestReboot = True + + config_spec._tools = tools_info + config_spec._numCPUs = int(instance.vcpus) + config_spec._memoryMB = int(instance.memory_mb) + + nic_spec = create_network_spec(network_name, instance.mac_address) + + device_config_spec = [nic_spec] + + config_spec._deviceChange = device_config_spec + return config_spec + + +def create_controller_spec(key): + """ + Builds a Config Spec for the LSI Logic Controller's addition which acts + as the controller for the Virtual Hard disk to be attached to the VM + """ + #Create a controller for the Virtual Hard Disk + virtual_device_config = \ + ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() + virtual_device_config._operation = "add" + virtual_lsi = \ + ns0.VirtualLsiLogicController_Def( + "VirtualLsiLogicController").pyclass() + virtual_lsi._key = key + virtual_lsi._busNumber = 0 + virtual_lsi._sharedBus = "noSharing" + virtual_device_config._device = virtual_lsi + + return virtual_device_config + + +def create_network_spec(network_name, mac_address): + """ + Builds a config spec for the addition of a new network adapter to the VM + """ + network_spec = \ + ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() + network_spec._operation = "add" + + #Get the recommended card type for the VM based on the guest OS of the VM + net_device = ns0.VirtualPCNet32_Def("VirtualPCNet32").pyclass() + + backing = \ + ns0.VirtualEthernetCardNetworkBackingInfo_Def( + "VirtualEthernetCardNetworkBackingInfo").pyclass() + backing._deviceName = network_name + + connectable_spec = \ + ns0.VirtualDeviceConnectInfo_Def("VirtualDeviceConnectInfo").pyclass() + connectable_spec._startConnected = True + connectable_spec._allowGuestControl = True + connectable_spec._connected = True + + net_device._connectable = connectable_spec + net_device._backing = backing + + #The Server assigns a Key to the device. Here we pass a -ve temporary key. + #-ve because actual keys are +ve numbers and we don't + #want a clash with the key that server might associate with the device + net_device._key = -47 + net_device._addressType = "manual" + net_device._macAddress = mac_address + net_device._wakeOnLanEnabled = True + + network_spec._device = net_device + return network_spec + + +def get_datastore_search_sepc(pattern=None): + """ + Builds the datastore search spec. + """ + host_datastore_browser_search_spec = \ + ns0.HostDatastoreBrowserSearchSpec_Def( + "HostDatastoreBrowserSearchSpec").pyclass() + file_query_flags = ns0.FileQueryFlags_Def("FileQueryFlags").pyclass() + file_query_flags._modification = False + file_query_flags._fileSize = True + file_query_flags._fileType = True + file_query_flags._fileOwner = True + host_datastore_browser_search_spec._details = file_query_flags + if pattern is not None: + host_datastore_browser_search_spec._matchPattern = pattern + return host_datastore_browser_search_spec + + +def get_vmdk_attach_config_sepc(disksize, file_path, adapter_type="lsiLogic"): + """ + Builds the vmdk attach config spec. + """ + config_spec = ns0.VirtualMachineConfigSpec_Def( + "VirtualMachineConfigSpec").pyclass() + + #The controller Key pertains to the Key of the LSI Logic Controller, which + #controls this Hard Disk + device_config_spec = [] + #For IDE devices, there are these two default controllers created in the + #VM having keys 200 and 201 + if adapter_type == "ide": + controller_key = 200 + else: + controller_key = -101 + controller_spec = create_controller_spec(controller_key) + device_config_spec.append(controller_spec) + virtual_device_config_spec = create_virtual_disk_spec(disksize, + controller_key, file_path) + + device_config_spec.append(virtual_device_config_spec) + + config_spec._deviceChange = device_config_spec + return config_spec + + +def get_vmdk_file_path_and_adapter_type(hardware_devices): + """ + Gets the vmdk file path and the storage adapter type + """ + if isinstance(hardware_devices.typecode, ns0.ArrayOfVirtualDevice_Def): + hardware_devices = hardware_devices.VirtualDevice + vmdk_file_path = None + vmdk_controler_key = None + + adapter_type_dict = {} + for device in hardware_devices: + if (isinstance(device.typecode, ns0.VirtualDisk_Def) and + isinstance(device.Backing.typecode, + ns0.VirtualDiskFlatVer2BackingInfo_Def)): + vmdk_file_path = device.Backing.FileName + vmdk_controler_key = device.ControllerKey + elif isinstance(device.typecode, ns0.VirtualLsiLogicController_Def): + adapter_type_dict[device.Key] = "lsiLogic" + elif isinstance(device.typecode, ns0.VirtualBusLogicController_Def): + adapter_type_dict[device.Key] = "busLogic" + elif isinstance(device.typecode, ns0.VirtualIDEController_Def): + adapter_type_dict[device.Key] = "ide" + elif isinstance(device.typecode, ns0.VirtualLsiLogicSASController_Def): + adapter_type_dict[device.Key] = "lsiLogic" + + adapter_type = adapter_type_dict.get(vmdk_controler_key, "") + + return vmdk_file_path, adapter_type + + +def get_copy_virtual_disk_spec(adapter_type="lsilogic"): + """ + Builds the Virtual Disk copy spec. + """ + dest_spec = ns0.VirtualDiskSpec_Def("VirtualDiskSpec").pyclass() + dest_spec.AdapterType = adapter_type + dest_spec.DiskType = "thick" + return dest_spec + + +def get_vmdk_create_spec(size_in_kb, adapter_type="lsiLogic"): + """ + Builds the virtual disk create sepc. + """ + create_vmdk_spec = \ + ns0.FileBackedVirtualDiskSpec_Def("VirtualDiskSpec").pyclass() + create_vmdk_spec._adapterType = adapter_type + create_vmdk_spec._diskType = "thick" + create_vmdk_spec._capacityKb = size_in_kb + return create_vmdk_spec + + +def create_virtual_disk_spec(disksize, controller_key, file_path=None): + """ + Creates a Spec for the addition/attaching of a Virtual Disk to the VM + """ + virtual_device_config = \ + ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() + virtual_device_config._operation = "add" + if file_path is None: + virtual_device_config._fileOperation = "create" + + virtual_disk = ns0.VirtualDisk_Def("VirtualDisk").pyclass() + + disk_file_backing = ns0.VirtualDiskFlatVer2BackingInfo_Def( + "VirtualDiskFlatVer2BackingInfo").pyclass() + disk_file_backing._diskMode = "persistent" + disk_file_backing._thinProvisioned = False + if file_path is not None: + disk_file_backing._fileName = file_path + else: + disk_file_backing._fileName = "" + + connectable_spec = ns0.VirtualDeviceConnectInfo_Def( + "VirtualDeviceConnectInfo").pyclass() + connectable_spec._startConnected = True + connectable_spec._allowGuestControl = False + connectable_spec._connected = True + + virtual_disk._backing = disk_file_backing + virtual_disk._connectable = connectable_spec + + #The Server assigns a Key to the device. Here we pass a -ve temporary key. + #-ve because actual keys are +ve numbers and we don't + #want a clash with the key that server might associate with the device + virtual_disk._key = -100 + virtual_disk._controllerKey = controller_key + virtual_disk._unitNumber = 0 + virtual_disk._capacityInKB = disksize + + virtual_device_config._device = virtual_disk + + return virtual_device_config + + +def get_dummy_vm_create_spec(name, data_store_name): + """ + Builds the dummy VM create spec + """ + config_spec = ns0.VirtualMachineConfigSpec_Def( + "VirtualMachineConfigSpec").pyclass() + + config_spec._name = name + config_spec._guestId = "otherGuest" + + vm_file_info = ns0.VirtualMachineFileInfo_Def( + "VirtualMachineFileInfo").pyclass() + vm_file_info._vmPathName = "[" + data_store_name + "]" + config_spec._files = vm_file_info + + tools_info = ns0.ToolsConfigInfo_Def("ToolsConfigInfo") + tools_info._afterPowerOn = True + tools_info._afterResume = True + tools_info._beforeGuestStandby = True + tools_info._bbeforeGuestShutdown = True + tools_info._beforeGuestReboot = True + + config_spec._tools = tools_info + config_spec._numCPUs = 1 + config_spec._memoryMB = 4 + + controller_key = -101 + controller_spec = create_controller_spec(controller_key) + disk_spec = create_virtual_disk_spec(1024, controller_key) + + device_config_spec = [controller_spec, disk_spec] + + config_spec._deviceChange = device_config_spec + return config_spec + + +def get_machine_id_change_spec(mac, ip_addr, netmask, gateway): + """ + Builds the machine id change config spec + """ + machine_id_str = "%s;%s;%s;%s" % (mac, ip_addr, netmask, gateway) + virtual_machine_config_spec = ns0.VirtualMachineConfigSpec_Def( + "VirtualMachineConfigSpec").pyclass() + opt = ns0.OptionValue_Def('OptionValue').pyclass() + opt._key = "machine.id" + opt._value = machine_id_str + virtual_machine_config_spec._extraConfig = [opt] + return virtual_machine_config_spec diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py new file mode 100644 index 000000000..23247a54e --- /dev/null +++ b/nova/virt/vmwareapi/vmops.py @@ -0,0 +1,724 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import logging +import os +import time +import uuid + +from nova import db +from nova import context +from nova.compute import power_state + +from nova.virt.vmwareapi import vim_util +from nova.virt.vmwareapi import vm_util +from nova.virt.vmwareapi import vmware_images + +LOG = logging.getLogger("nova.virt.vmwareapi.vmops") + +VMWARE_POWER_STATES = { + 'poweredOff': power_state.SHUTDOWN, + 'poweredOn': power_state.RUNNING, + 'suspended': power_state.PAUSED} + + +class VMWareVMOps(object): + """ + Management class for VM-related tasks + """ + + def __init__(self, session): + """ + Initializer + """ + self._session = session + + def _wait_with_callback(self, instance_id, task, callback): + """ + Waits for the task to finish and does a callback after + """ + ret = None + try: + ret = self._session._wait_for_task(instance_id, task) + except Exception, excep: + LOG.exception(excep) + callback(ret) + + def list_instances(self): + """ + Lists the VM instances that are registered with the ESX host + """ + LOG.debug("Getting list of instances") + vms = self._session._call_method(vim_util, "get_objects", + "VirtualMachine", + ["name", "runtime.connectionState"]) + lst_vm_names = [] + for vm in vms: + vm_name = None + conn_state = None + for prop in vm.PropSet: + if prop.Name == "name": + vm_name = prop.Val + elif prop.Name == "runtime.connectionState": + conn_state = prop.Val + # Ignoring the oprhaned or inaccessible VMs + if conn_state not in ["orphaned", "inaccessible"]: + lst_vm_names.append(vm_name) + LOG.debug("Got total of %s instances" % str(len(lst_vm_names))) + return lst_vm_names + + def spawn(self, instance): + """ + Creates a VM instance. + + Steps followed are: + 1. Create a VM with no disk and the specifics in the instance object + like RAM size. + 2. Create a dummy vmdk of the size of the disk file that is to be + uploaded. This is required just to create the metadata file. + 3. Delete the -flat.vmdk file created in the above step and retain + the metadata .vmdk file. + 4. Upload the disk file. + 5. Attach the disk to the VM by reconfiguring the same. + 6. Power on the VM + """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref: + raise Exception('Attempted to create a VM with a name %s, ' + 'but that already exists on the host' % instance.name) + bridge = db.network_get_by_instance(context.get_admin_context(), + instance['id'])['bridge'] + #TODO: Shouldn't we consider any public network in case the network + #name supplied isn't there + network_ref = \ + self._get_network_with_the_name(bridge) + if network_ref is None: + raise Exception("Network with the name '%s' doesn't exist on " + "the ESX host" % bridge) + + #Get the Size of the flat vmdk file that is there on the storage + #repository. + image_size, image_properties = \ + vmware_images.get_vmdk_size_and_properties(instance.image_id, + instance) + vmdk_file_size_in_kb = int(image_size) / 1024 + os_type = image_properties.get("vmware_ostype", "otherGuest") + adapter_type = image_properties.get("vmware_adaptertype", "lsiLogic") + + # Get the datastore list and choose the first local storage + data_stores = self._session._call_method(vim_util, "get_objects", + "Datastore", ["summary.type", "summary.name"]) + data_store_name = None + for elem in data_stores: + ds_name = None + ds_type = None + for prop in elem.PropSet: + if prop.Name == "summary.type": + ds_type = prop.Val + elif prop.Name == "summary.name": + ds_name = prop.Val + #Local storage identifier + if ds_type == "VMFS": + data_store_name = ds_name + break + + if data_store_name is None: + msg = "Couldn't get a local Datastore reference" + LOG.exception(msg) + raise Exception(msg) + + config_spec = vm_util.get_vm_create_spec(instance, data_store_name, + bridge, os_type) + + #Get the Vm folder ref from the datacenter + dc_objs = self._session._call_method(vim_util, "get_objects", + "Datacenter", ["vmFolder"]) + #There is only one default datacenter in a standalone ESX host + vm_folder_ref = dc_objs[0].PropSet[0].Val + + #Get the resource pool. Taking the first resource pool coming our way. + #Assuming that is the default resource pool. + res_pool_mor = self._session._call_method(vim_util, "get_objects", + "ResourcePool")[0].Obj + + LOG.debug("Creating VM with the name %s on the ESX host" % + instance.name) + #Create the VM on the ESX host + vm_create_task = self._session._call_method(self._session._get_vim(), + "CreateVM_Task", vm_folder_ref, + config=config_spec, pool=res_pool_mor) + self._session._wait_for_task(instance.id, vm_create_task) + + LOG.debug("Created VM with the name %s on the ESX host" % + instance.name) + + # Set the machine id for the VM for setting the IP + self._set_machine_id(instance) + + #Naming the VM files in correspondence with the VM instance name + + # The flat vmdk file name + flat_uploaded_vmdk_name = "%s/%s-flat.vmdk" % (instance.name, + instance.name) + #The vmdk meta-data file + uploaded_vmdk_name = "%s/%s.vmdk" % (instance.name, instance.name) + flat_uploaded_vmdk_path = vm_util.build_datastore_path(data_store_name, + flat_uploaded_vmdk_name) + uploaded_vmdk_path = vm_util.build_datastore_path(data_store_name, + uploaded_vmdk_name) + + #Create a Virtual Disk of the size of the flat vmdk file. This is done + #just created to generate the meta-data file whose specifics + #depend on the size of the disk, thin/thick provisioning and the + #storage adapter type. + #Here we assume thick provisioning and lsiLogic for the adapter type + LOG.debug("Creating Virtual Disk of size %s KB and adapter type %s on " + "the ESX host local store %s " % + (vmdk_file_size_in_kb, adapter_type, data_store_name)) + vmdk_create_spec = vm_util.get_vmdk_create_spec(vmdk_file_size_in_kb, + adapter_type) + vmdk_create_task = self._session._call_method(self._session._get_vim(), + "CreateVirtualDisk_Task", + self._session._get_vim().get_service_content().VirtualDiskManager, + name=uploaded_vmdk_path, + datacenter=self._get_datacenter_name_and_ref()[0], + spec=vmdk_create_spec) + self._session._wait_for_task(instance.id, vmdk_create_task) + LOG.debug("Created Virtual Disk of size %s KB on the ESX host local" + "store %s " % (vmdk_file_size_in_kb, data_store_name)) + + LOG.debug("Deleting the file %s on the ESX host local" + "store %s " % (flat_uploaded_vmdk_path, data_store_name)) + #Delete the -flat.vmdk file created. .vmdk file is retained. + vmdk_delete_task = self._session._call_method(self._session._get_vim(), + "DeleteDatastoreFile_Task", + self._session._get_vim().get_service_content().FileManager, + name=flat_uploaded_vmdk_path) + self._session._wait_for_task(instance.id, vmdk_delete_task) + LOG.debug("Deleted the file %s on the ESX host local" + "store %s " % (flat_uploaded_vmdk_path, data_store_name)) + + LOG.debug("Downloading image file data %s to the ESX data store %s " % + (instance.image_id, data_store_name)) + # Upload the -flat.vmdk file whose meta-data file we just created above + vmware_images.fetch_image( + instance.image_id, + instance, + host=self._session._host_ip, + data_center_name=self._get_datacenter_name_and_ref()[1], + datastore_name=data_store_name, + cookies=self._session._get_vim().proxy.binding.cookies, + file_path=flat_uploaded_vmdk_name) + LOG.debug("Downloaded image file data %s to the ESX data store %s " % + (instance.image_id, data_store_name)) + + #Attach the vmdk uploaded to the VM. VM reconfigure is done to do so. + vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_sepc( + vmdk_file_size_in_kb, uploaded_vmdk_path, + adapter_type) + vm_ref = self._get_vm_ref_from_the_name(instance.name) + LOG.debug("Reconfiguring VM instance %s to attach the image " + "disk" % instance.name) + reconfig_task = self._session._call_method(self._session._get_vim(), + "ReconfigVM_Task", vm_ref, + spec=vmdk_attach_config_spec) + self._session._wait_for_task(instance.id, reconfig_task) + LOG.debug("Reconfigured VM instance %s to attach the image " + "disk" % instance.name) + + LOG.debug("Powering on the VM instance %s " % instance.name) + #Power On the VM + power_on_task = self._session._call_method(self._session._get_vim(), + "PowerOnVM_Task", vm_ref) + self._session._wait_for_task(instance.id, power_on_task) + LOG.debug("Powered on the VM instance %s " % instance.name) + + def snapshot(self, instance, snapshot_name): + """ + Create snapshot from a running VM instance. + Steps followed are: + 1. Get the name of the vmdk file which the VM points to right now. + Can be a chain of snapshots, so we need to know the last in the + chain. + 2. Create the snapshot. A new vmdk is created which the VM points to + now. The earlier vmdk becomes read-only. + 3. Call CopyVirtualDisk which coalesces the disk chain to form a single + vmdk, rather a .vmdk metadata file and a -flat.vmdk disk data file. + 4. Now upload the -flat.vmdk file to the image store. + 5. Delete the coalesced .vmdk and -flat.vmdk created + """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref is None: + raise Exception("instance - %s not present" % instance.name) + + #Get the vmdk file name that the VM is pointing to + hardware_devices = self._session._call_method(vim_util, + "get_dynamic_property", vm_ref, + "VirtualMachine", "config.hardware.device") + vmdk_file_path_before_snapshot, adapter_type = \ + vm_util.get_vmdk_file_path_and_adapter_type(hardware_devices) + + os_type = self._session._call_method(vim_util, + "get_dynamic_property", vm_ref, + "VirtualMachine", "summary.config.guestId") + #Create a snapshot of the VM + LOG.debug("Creating Snapshot of the VM instance %s " % instance.name) + snapshot_task = self._session._call_method(self._session._get_vim(), + "CreateSnapshot_Task", vm_ref, + name="%s-snapshot" % instance.name, + description="Taking Snapshot of the VM", + memory=True, + quiesce=True) + self._session._wait_for_task(instance.id, snapshot_task) + LOG.debug("Created Snapshot of the VM instance %s " % instance.name) + + datastore_name = vm_util.split_datastore_path( + vmdk_file_path_before_snapshot)[0] + #Copy the contents of the VM that were there just before the snapshot + #was taken + ds_ref = vim_util.get_dynamic_property(self._session._get_vim(), + vm_ref, + "VirtualMachine", + "datastore").ManagedObjectReference[0] + ds_browser = vim_util.get_dynamic_property(self._session._get_vim(), + ds_ref, + "Datastore", + "browser") + #Check if the vmware-tmp folder exists or not. If not, create one + tmp_folder_path = vm_util.build_datastore_path(datastore_name, + "vmware-tmp") + if not self._path_exists(ds_browser, tmp_folder_path): + self._mkdir(vm_util.build_datastore_path(datastore_name, + "vmware-tmp")) + + copy_spec = vm_util.get_copy_virtual_disk_spec(adapter_type) + + #Generate a random vmdk file name to which the coalesced vmdk content + #will be copied to. A random name is chosen so that we don't have + #name clashes. + random_name = str(uuid.uuid4()) + dest_vmdk_file_location = vm_util.build_datastore_path(datastore_name, + "vmware-tmp/%s.vmdk" % random_name) + dc_ref = self._get_datacenter_name_and_ref()[0] + + #Copy the contents of the disk ( or disks, if there were snapshots + #done earlier) to a temporary vmdk file. + LOG.debug("Copying disk data before snapshot of the VM instance %s " % + instance.name) + copy_disk_task = self._session._call_method(self._session._get_vim(), + "CopyVirtualDisk_Task", + self._session._get_vim().get_service_content().VirtualDiskManager, + sourceName=vmdk_file_path_before_snapshot, + sourceDatacenter=dc_ref, + destName=dest_vmdk_file_location, + destDatacenter=dc_ref, + destSpec=copy_spec, + force=False) + self._session._wait_for_task(instance.id, copy_disk_task) + LOG.debug("Copied disk data before snapshot of the VM instance %s " % + instance.name) + + #Upload the contents of -flat.vmdk file which has the disk data. + LOG.debug("Uploading image %s" % snapshot_name) + vmware_images.upload_image( + snapshot_name, + instance, + os_type=os_type, + adapter_type=adapter_type, + image_version=1, + host=self._session._host_ip, + data_center_name=self._get_datacenter_name_and_ref()[1], + datastore_name=datastore_name, + cookies=self._session._get_vim().proxy.binding.cookies, + file_path="vmware-tmp/%s-flat.vmdk" % random_name) + LOG.debug("Uploaded image %s" % snapshot_name) + + #Delete the temporary vmdk created above. + LOG.debug("Deleting temporary vmdk file %s" % dest_vmdk_file_location) + remove_disk_task = self._session._call_method(self._session._get_vim(), + "DeleteVirtualDisk_Task", + self._session._get_vim().get_service_content().VirtualDiskManager, + name=dest_vmdk_file_location, + datacenter=dc_ref) + self._session._wait_for_task(instance.id, remove_disk_task) + LOG.debug("Deleted temporary vmdk file %s" % dest_vmdk_file_location) + + def reboot(self, instance): + """ + Reboot a VM instance + """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref is None: + raise Exception("instance - %s not present" % instance.name) + lst_properties = ["summary.guest.toolsStatus", "runtime.powerState"] + props = self._session._call_method(vim_util, "get_object_properties", + None, vm_ref, "VirtualMachine", + lst_properties) + for elem in props: + pwr_state = None + tools_status = None + for prop in elem.PropSet: + if prop.Name == "runtime.powerState": + pwr_state = prop.Val + elif prop.Name == "summary.guest.toolsStatus": + tools_status = prop.Val + + #Raise an exception if the VM is not powered On. + if pwr_state not in ["poweredOn"]: + raise Exception("instance - %s not poweredOn. So can't be " + "rebooted." % instance.name) + + #If vmware tools are installed in the VM, then do a guest reboot. + #Otherwise do a hard reset. + if tools_status not in ['toolsNotInstalled', 'toolsNotRunning']: + LOG.debug("Rebooting guest OS of VM %s" % instance.name) + self._session._call_method(self._session._get_vim(), "RebootGuest", + vm_ref) + LOG.debug("Rebooted guest OS of VM %s" % instance.name) + else: + LOG.debug("Doing hard reboot of VM %s" % instance.name) + reset_task = self._session._call_method(self._session._get_vim(), + "ResetVM_Task", vm_ref) + self._session._wait_for_task(instance.id, reset_task) + LOG.debug("Did hard reboot of VM %s" % instance.name) + + def destroy(self, instance): + """ + Destroy a VM instance. Steps followed are: + 1. Power off the VM, if it is in poweredOn state. + 2. Un-register a VM. + 3. Delete the contents of the folder holding the VM related data + """ + try: + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref is None: + LOG.debug("instance - %s not present" % instance.name) + return + lst_properties = ["config.files.vmPathName", "runtime.powerState"] + props = self._session._call_method(vim_util, + "get_object_properties", + None, vm_ref, "VirtualMachine", lst_properties) + pwr_state = None + for elem in props: + vm_config_pathname = None + for prop in elem.PropSet: + if prop.Name == "runtime.powerState": + pwr_state = prop.Val + elif prop.Name == "config.files.vmPathName": + vm_config_pathname = prop.Val + if vm_config_pathname: + datastore_name, vmx_file_path = \ + vm_util.split_datastore_path(vm_config_pathname) + #Power off the VM if it is in PoweredOn state. + if pwr_state == "poweredOn": + LOG.debug("Powering off the VM %s" % instance.name) + poweroff_task = self._session._call_method( + self._session._get_vim(), + "PowerOffVM_Task", vm_ref) + self._session._wait_for_task(instance.id, poweroff_task) + LOG.debug("Powered off the VM %s" % instance.name) + + #Un-register the VM + try: + LOG.debug("Unregistering the VM %s" % instance.name) + self._session._call_method(self._session._get_vim(), + "UnregisterVM", vm_ref) + LOG.debug("Unregistered the VM %s" % instance.name) + except Exception, excep: + LOG.warn("In vmwareapi:vmops:destroy, got this exception while" + " un-registering the VM: " + str(excep)) + + #Delete the folder holding the VM related content on the datastore. + try: + dir_ds_compliant_path = vm_util.build_datastore_path( + datastore_name, + os.path.dirname(vmx_file_path)) + LOG.debug("Deleting contents of the VM %s from datastore %s " % + (instance.name, datastore_name)) + delete_task = self._session._call_method( + self._session._get_vim(), + "DeleteDatastoreFile_Task", + self._session._get_vim().get_service_content().FileManager, + name=dir_ds_compliant_path) + self._session._wait_for_task(instance.id, delete_task) + LOG.debug("Deleted contents of the VM %s from datastore %s " % + (instance.name, datastore_name)) + except Exception, excep: + LOG.warn("In vmwareapi:vmops:destroy, " + "got this exception while deleting" + " the VM contents from the disk: " + str(excep)) + except Exception, e: + LOG.exception(e) + + def pause(self, instance, callback): + """ + Pause a VM instance + """ + return "Not Implemented" + + def unpause(self, instance, callback): + """ + Un-Pause a VM instance + """ + return "Not Implemented" + + def suspend(self, instance, callback): + """ + Suspend the specified instance + """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref is None: + raise Exception("instance - %s not present" % instance.name) + + pwr_state = self._session._call_method(vim_util, + "get_dynamic_property", vm_ref, + "VirtualMachine", "runtime.powerState") + #Only PoweredOn VMs can be suspended. + if pwr_state == "poweredOn": + LOG.debug("Suspending the VM %s " % instance.name) + suspend_task = self._session._call_method(self._session._get_vim(), + "SuspendVM_Task", vm_ref) + self._wait_with_callback(instance.id, suspend_task, callback) + LOG.debug("Suspended the VM %s " % instance.name) + #Raise Exception if VM is poweredOff + elif pwr_state == "poweredOff": + raise Exception("instance - %s is poweredOff and hence can't " + "be suspended." % instance.name) + LOG.debug("VM %s was already in suspended state. So returning without " + "doing anything" % instance.name) + + def resume(self, instance, callback): + """ + Resume the specified instance + """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref is None: + raise Exception("instance - %s not present" % instance.name) + + pwr_state = self._session._call_method(vim_util, + "get_dynamic_property", vm_ref, + "VirtualMachine", "runtime.powerState") + if pwr_state.lower() == "suspended": + LOG.debug("Resuming the VM %s " % instance.name) + suspend_task = self._session._call_method( + self._session._get_vim(), + "PowerOnVM_Task", vm_ref) + self._wait_with_callback(instance.id, suspend_task, callback) + LOG.debug("Resumed the VM %s " % instance.name) + else: + raise Exception("instance - %s not in Suspended state and hence " + "can't be Resumed." % instance.name) + + def get_info(self, instance_name): + """ + Return data about the VM instance + """ + vm_ref = self._get_vm_ref_from_the_name(instance_name) + if vm_ref is None: + raise Exception("instance - %s not present" % instance_name) + + lst_properties = ["summary.config.numCpu", + "summary.config.memorySizeMB", + "runtime.powerState"] + vm_props = self._session._call_method(vim_util, + "get_object_properties", None, vm_ref, "VirtualMachine", + lst_properties) + max_mem = None + pwr_state = None + num_cpu = None + for elem in vm_props: + for prop in elem.PropSet: + if prop.Name == "summary.config.numCpu": + num_cpu = int(prop.Val) + elif prop.Name == "summary.config..memorySizeMB": + # In MB, but we want in KB + max_mem = int(prop.Val) * 1024 + elif prop.Name == "runtime.powerState": + pwr_state = VMWARE_POWER_STATES[prop.Val] + + return {'state': pwr_state, + 'max_mem': max_mem, + 'mem': max_mem, + 'num_cpu': num_cpu, + 'cpu_time': 0} + + def get_diagnostics(self, instance): + """ + Return data about VM diagnostics + """ + return "Not Implemented" + + def get_console_output(self, instance): + """ + Return snapshot of console + """ + return 'FAKE CONSOLE OUTPUT of instance' + + def get_ajax_console(self, instance): + """ + Return link to instance's ajax console + """ + return 'http://fakeajaxconsole/fake_url' + + def _set_machine_id(self, instance): + """ + Set the machine id of the VM for guest tools to pick up and change the + IP + """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref is None: + raise Exception("instance - %s not present" % instance.name) + network = db.network_get_by_instance(context.get_admin_context(), + instance['id']) + mac_addr = instance.mac_address + net_mask = network["netmask"] + gateway = network["gateway"] + ip_addr = db.instance_get_fixed_address(context.get_admin_context(), + instance['id']) + machine_id_chanfge_spec = vm_util.get_machine_id_change_spec(mac_addr, + ip_addr, net_mask, gateway) + LOG.debug("Reconfiguring VM instance %s to set the machine id " + "with ip - %s" % (instance.name, ip_addr)) + reconfig_task = self._session._call_method(self._session._get_vim(), + "ReconfigVM_Task", vm_ref, + spec=machine_id_chanfge_spec) + self._session._wait_for_task(instance.id, reconfig_task) + LOG.debug("Reconfigured VM instance %s to set the machine id " + "with ip - %s" % (instance.name, ip_addr)) + + def _create_dummy_vm_for_test(self, instance): + """ + Create a dummy VM for testing purpose + """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref: + raise Exception('Attempted to create a VM with a name %s, ' + 'but that already exists on the host' % instance.name) + + data_stores = self._session._call_method(vim_util, "get_objects", + "Datastore", ["summary.type", "summary.name"]) + data_store_name = None + for elem in data_stores: + ds_name = None + ds_type = None + for prop in elem.PropSet: + if prop.Name == "summary.type": + ds_type = prop.Val + elif prop.Name == "summary.name": + ds_name = prop.Val + #Local storage identifier + if ds_type == "VMFS": + data_store_name = ds_name + break + + if data_store_name is None: + msg = "Couldn't get a local Datastore reference" + LOG.exception(msg) + raise Exception(msg) + + config_spec = vm_util.get_dummy_vm_create_spec(instance.name, + data_store_name) + + #Get the Vm folder ref from the datacenter + dc_objs = self._session._call_method(vim_util, "get_objects", + "Datacenter", ["vmFolder"]) + #There is only one default datacenter in a standalone ESX host + vm_folder_ref = dc_objs[0].PropSet[0].Val + + #Get the resource pool. Taking the first resource pool coming our way. + #Assuming that is the default resource pool. + res_pool_mor = self._session._call_method(vim_util, "get_objects", + "ResourcePool")[0].Obj + + #Create the VM on the ESX host + vm_create_task = self._session._call_method(self._session._get_vim(), + "CreateVM_Task", vm_folder_ref, + config=config_spec, pool=res_pool_mor) + self._session._wait_for_task(instance.id, vm_create_task) + + vm_ref = self._get_vm_ref_from_the_name(instance.name) + power_on_task = self._session._call_method(self._session._get_vim(), + "PowerOnVM_Task", vm_ref) + self._session._wait_for_task(instance.id, power_on_task) + + def _get_network_with_the_name(self, network_name="vmnet0"): + ''' + Gets reference to the network whose name is passed as the argument. + ''' + datacenters = self._session._call_method(vim_util, "get_objects", + "Datacenter", ["network"]) + vm_networks = datacenters[0].PropSet[0].Val.ManagedObjectReference + networks = self._session._call_method(vim_util, + "get_properites_for_a_collection_of_objects", + "Network", vm_networks, ["summary.name"]) + for network in networks: + if network.PropSet[0].Val == network_name: + return network.Obj + return None + + def _get_datacenter_name_and_ref(self): + """ + Get the datacenter name and the reference. + """ + dc_obj = self._session._call_method(vim_util, "get_objects", + "Datacenter", ["name"]) + return dc_obj[0].Obj, dc_obj[0].PropSet[0].Val + + def _path_exists(self, ds_browser, ds_path): + """ + Check if the path exists on the datastore + """ + search_task = self._session._call_method(self._session._get_vim(), + "SearchDatastore_Task", + ds_browser, + datastorePath=ds_path) + #Wait till the state changes from queued or running. + #If an error state is returned, it means that the path doesn't exist. + while True: + task_info = self._session._call_method(vim_util, + "get_dynamic_property", + search_task, "Task", "info") + if task_info.State in ['queued', 'running']: + time.sleep(2) + continue + break + if task_info.State == "error": + return False + return True + + def _mkdir(self, ds_path): + """ + Creates a directory at the path specified. If it is just "NAME", then a + directory with this name is formed at the topmost level of the + DataStore. + """ + LOG.debug("Creating directory with path %s" % ds_path) + self._session._call_method(self._session._get_vim(), "MakeDirectory", + self._session._get_vim().get_service_content().FileManager, + name=ds_path, createParentDirectories=False) + LOG.debug("Created directory with path %s" % ds_path) + + def _get_vm_ref_from_the_name(self, vm_name): + """ + Get reference to the VM with the name specified. + """ + vms = self._session._call_method(vim_util, "get_objects", + "VirtualMachine", ["name"]) + for vm in vms: + if vm.PropSet[0].Val == vm_name: + return vm.Obj + return None diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py new file mode 100644 index 000000000..aa3b263cd --- /dev/null +++ b/nova/virt/vmwareapi/vmware_images.py @@ -0,0 +1,257 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import time +import os +import logging + +from nova import flags + +from nova.virt.vmwareapi import read_write_util +from nova.virt.vmwareapi import io_util + +FLAGS = flags.FLAGS + +QUEUE_BUFFER_SIZE = 5 +READ_CHUNKSIZE = 2 * 1024 * 1024 +WRITE_CHUNKSIZE = 2 * 1024 * 1024 + +LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images") + + +def start_transfer(read_file_handle, write_file_handle, data_size): + """ + Start the data transfer from the read handle to the write handle. + """ + #The thread safe pipe + thread_safe_pipe = io_util.ThreadSafePipe(QUEUE_BUFFER_SIZE) + #The read thread + read_thread = io_util.IOThread(read_file_handle, thread_safe_pipe, + READ_CHUNKSIZE, long(data_size)) + #The write thread + write_thread = io_util.IOThread(thread_safe_pipe, write_file_handle, + WRITE_CHUNKSIZE, long(data_size)) + read_thread.start() + write_thread.start() + LOG.debug("Starting image file transfer") + #Wait till both the read thread and the write thread are done + while not (read_thread.is_done() and write_thread.is_done()): + if read_thread.get_error() or write_thread.get_error(): + read_thread.stop_io_transfer() + write_thread.stop_io_transfer() + # If there was an exception in reading or writing, raise the same. + read_excep = read_thread.get_exception() + write_excep = write_thread.get_exception() + if read_excep is not None: + LOG.exception(str(read_excep)) + raise Exception(read_excep) + if write_excep is not None: + LOG.exception(str(write_excep)) + raise Exception(write_excep) + time.sleep(2) + LOG.debug("Finished image file transfer and closing the file handles") + #Close the file handles + read_file_handle.close() + write_file_handle.close() + + +def fetch_image(image, instance, **kwargs): + """ + Fetch an image for attaching to the newly created VM + """ + #Depending upon the image service, make appropriate image service call + if FLAGS.image_service == "nova.image.glance.GlanceImageService": + func = _get_glance_image + elif FLAGS.image_service == "nova.image.s3.S3ImageService": + func = _get_s3_image + elif FLAGS.image_service == "nova.image.local.LocalImageService": + func = _get_local_image + elif FLAGS.image_service == "nova.FakeImageService": + func = _get_fake_image + else: + raise NotImplementedError("The Image Service %s is not implemented" + % FLAGS.image_service) + return func(image, instance, **kwargs) + + +def upload_image(image, instance, **kwargs): + """ + Upload the newly snapshotted VM disk file. + """ + #Depending upon the image service, make appropriate image service call + if FLAGS.image_service == "nova.image.glance.GlanceImageService": + func = _put_glance_image + elif FLAGS.image_service == "nova.image.s3.S3ImageService": + func = _put_s3_image + elif FLAGS.image_service == "nova.image.local.LocalImageService": + func = _put_local_image + elif FLAGS.image_service == "nova.FakeImageService": + func = _put_fake_image + else: + raise NotImplementedError("The Image Service %s is not implemented" + % FLAGS.image_service) + return func(image, instance, **kwargs) + + +def _get_glance_image(image, instance, **kwargs): + """ + Download image from the glance image server. + """ + LOG.debug("Downloading image %s from glance image server" % image) + read_file_handle = read_write_util.GlanceHTTPReadFile(FLAGS.glance_host, + FLAGS.glance_port, + image) + file_size = read_file_handle.get_size() + write_file_handle = read_write_util.VMWareHTTPWriteFile( + kwargs.get("host"), + kwargs.get("data_center_name"), + kwargs.get("datastore_name"), + kwargs.get("cookies"), + kwargs.get("file_path"), + file_size) + start_transfer(read_file_handle, write_file_handle, file_size) + LOG.debug("Downloaded image %s from glance image server" % image) + + +def _get_s3_image(image, instance, **kwargs): + """ + Download image from the S3 image server. + """ + raise NotImplementedError + + +def _get_local_image(image, instance, **kwargs): + """ + Download image from the local nova compute node. + """ + raise NotImplementedError + + +def _get_fake_image(image, instance, **kwargs): + """ + Download a fake image from the nova local file repository for testing + purposes + """ + LOG.debug("Downloading image %s from fake image service" % image) + image = str(image) + file_path = os.path.join("/tmp/vmware-test-images", image, image) + file_path = os.path.abspath(file_path) + read_file_handle = read_write_util.FakeFileRead(file_path) + file_size = read_file_handle.get_size() + write_file_handle = read_write_util.VMWareHTTPWriteFile( + kwargs.get("host"), + kwargs.get("data_center_name"), + kwargs.get("datastore_name"), + kwargs.get("cookies"), + kwargs.get("file_path"), + file_size) + start_transfer(read_file_handle, write_file_handle, file_size) + LOG.debug("Downloaded image %s from fake image service" % image) + + +def _put_glance_image(image, instance, **kwargs): + """ + Upload the snapshotted vm disk file to Glance image server + """ + LOG.debug("Uploading image %s to the Glance image server" % image) + read_file_handle = read_write_util.VmWareHTTPReadFile( + kwargs.get("host"), + kwargs.get("data_center_name"), + kwargs.get("datastore_name"), + kwargs.get("cookies"), + kwargs.get("file_path")) + file_size = read_file_handle.get_size() + write_file_handle = read_write_util.GlanceHTTPWriteFile( + FLAGS.glance_host, + FLAGS.glance_port, + image, + file_size, + kwargs.get("os_type"), + kwargs.get("adapter_type"), + kwargs.get("image_version")) + start_transfer(read_file_handle, write_file_handle, file_size) + LOG.debug("Uploaded image %s to the Glance image server" % image) + + +def _put_local_image(image, instance, **kwargs): + """ + Upload the snapshotted vm disk file to the local nova compute node. + """ + raise NotImplementedError + + +def _put_s3_image(image, instance, **kwargs): + """ + Upload the snapshotted vm disk file to S3 image server. + """ + raise NotImplementedError + + +def _put_fake_image(image, instance, **kwargs): + """ + Upload a dummy vmdk from the ESX host to the local file repository of + the nova node for testing purposes + """ + LOG.debug("Uploading image %s to the Fake Image Service" % image) + read_file_handle = read_write_util.VmWareHTTPReadFile( + kwargs.get("host"), + kwargs.get("data_center_name"), + kwargs.get("datastore_name"), + kwargs.get("cookies"), + kwargs.get("file_path")) + file_size = read_file_handle.get_size() + image = str(image) + image_dir_path = os.path.join("/tmp/vmware-test-images", image) + if not os.path.exists("/tmp/vmware-test-images"): + os.mkdir("/tmp/vmware-test-images") + os.mkdir(image_dir_path) + else: + if not os.path.exists(image_dir_path): + os.mkdir(image_dir_path) + file_path = os.path.join(image_dir_path, image) + file_path = os.path.abspath(file_path) + write_file_handle = read_write_util.FakeFileWrite(file_path) + start_transfer(read_file_handle, write_file_handle, file_size) + LOG.debug("Uploaded image %s to the Fake Image Service" % image) + + +def get_vmdk_size_and_properties(image, instance): + """ + Get size of the vmdk file that is to be downloaded for attach in spawn. + Need this to create the dummy virtual disk for the meta-data file. The + geometry of the disk created depends on the size. + """ + LOG.debug("Getting image size for the image %s" % image) + if FLAGS.image_service == "nova.image.glance.GlanceImageService": + read_file_handle = read_write_util.GlanceHTTPReadFile( + FLAGS.glance_host, + FLAGS.glance_port, + image) + elif FLAGS.image_service == "nova.image.s3.S3ImageService": + raise NotImplementedError + elif FLAGS.image_service == "nova.image.local.LocalImageService": + raise NotImplementedError + elif FLAGS.image_service == "nova.FakeImageService": + image = str(image) + file_path = os.path.join("/tmp/vmware-test-images", image, image) + file_path = os.path.abspath(file_path) + read_file_handle = read_write_util.FakeFileRead(file_path) + size = read_file_handle.get_size() + properties = read_file_handle.get_image_properties() + read_file_handle.close() + LOG.debug("Got image size of %s for the image %s" % (size, image)) + return size, properties diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py new file mode 100644 index 000000000..d53a1c129 --- /dev/null +++ b/nova/virt/vmwareapi_conn.py @@ -0,0 +1,384 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import logging +import time +import urlparse + +from eventlet import event + +from nova import context +from nova import db +from nova import flags +from nova import utils + +from nova.virt.vmwareapi import vim +from nova.virt.vmwareapi import vim_util +from nova.virt.vmwareapi.vmops import VMWareVMOps + +LOG = logging.getLogger("nova.virt.vmwareapi_conn") + +FLAGS = flags.FLAGS +flags.DEFINE_string('vmwareapi_host_ip', + None, + 'URL for connection to VMWare ESX host.' + 'Required if connection_type is vmwareapi.') +flags.DEFINE_string('vmwareapi_host_username', + None, + 'Username for connection to VMWare ESX host.' + 'Used only if connection_type is vmwareapi.') +flags.DEFINE_string('vmwareapi_host_password', + None, + 'Password for connection to VMWare ESX host.' + 'Used only if connection_type is vmwareapi.') +flags.DEFINE_float('vmwareapi_task_poll_interval', + 1.0, + 'The interval used for polling of remote tasks ' + 'Used only if connection_type is vmwareapi') +flags.DEFINE_float('vmwareapi_api_retry_count', + 10, + 'The number of times we retry on failures, ' + 'e.g., socket error, etc.' + 'Used only if connection_type is vmwareapi') + +TIME_BETWEEN_API_CALL_RETRIES = 2.0 + + +class Failure(Exception): + """ + Base Exception class for handling task failures + """ + + def __init__(self, details): + """ + Initializer + """ + self.details = details + + def __str__(self): + """ + The informal string representation of the object + """ + return str(self.details) + + +def get_connection(_): + """ + Sets up the ESX host connection + """ + host_ip = FLAGS.vmwareapi_host_ip + host_username = FLAGS.vmwareapi_host_username + host_password = FLAGS.vmwareapi_host_password + api_retry_count = FLAGS.vmwareapi_api_retry_count + if not host_ip or host_username is None or host_password is None: + raise Exception('Must specify vmwareapi_host_ip,' + 'vmwareapi_host_username ' + 'and vmwareapi_host_password to use' + 'connection_type=vmwareapi') + return VMWareESXConnection(host_ip, host_username, host_password, + api_retry_count) + + +class VMWareESXConnection(object): + """ + The ESX host connection object + """ + + def __init__(self, host_ip, host_username, host_password, + api_retry_count, scheme="https"): + """ + The Initializer + """ + session = VMWareAPISession(host_ip, host_username, host_password, + api_retry_count, scheme=scheme) + self._vmops = VMWareVMOps(session) + + def init_host(self, host): + """ + Do the initialization that needs to be done + """ + #FIXME(sateesh): implement this + pass + + def list_instances(self): + """ + List VM instances + """ + return self._vmops.list_instances() + + def spawn(self, instance): + """ + Create VM instance + """ + self._vmops.spawn(instance) + + def snapshot(self, instance, name): + """ + Create snapshot from a running VM instance + """ + self._vmops.snapshot(instance, name) + + def reboot(self, instance): + """ + Reboot VM instance + """ + self._vmops.reboot(instance) + + def destroy(self, instance): + """ + Destroy VM instance + """ + self._vmops.destroy(instance) + + def pause(self, instance, callback): + """ + Pause VM instance + """ + self._vmops.pause(instance, callback) + + def unpause(self, instance, callback): + """ + Unpause paused VM instance + """ + self._vmops.unpause(instance, callback) + + def suspend(self, instance, callback): + """ + Suspend the specified instance + """ + self._vmops.suspend(instance, callback) + + def resume(self, instance, callback): + """ + Resume the suspended VM instance + """ + self._vmops.resume(instance, callback) + + def get_info(self, instance_id): + """ + Return info about the VM instance + """ + return self._vmops.get_info(instance_id) + + def get_diagnostics(self, instance): + """ + Return data about VM diagnostics + """ + return self._vmops.get_info(instance) + + def get_console_output(self, instance): + """ + Return snapshot of console + """ + return self._vmops.get_console_output(instance) + + def get_ajax_console(self, instance): + """ + Return link to instance's ajax console + """ + return self._vmops.get_ajax_console(instance) + + def attach_volume(self, instance_name, device_path, mountpoint): + """ + Attach volume storage to VM instance + """ + pass + + def detach_volume(self, instance_name, mountpoint): + """ + Detach volume storage to VM instance + """ + pass + + def get_console_pool_info(self, console_type): + """ + Get info about the host on which the VM resides + """ + esx_url = urlparse.urlparse(FLAGS.vmwareapi_host_ip) + return {'address': esx_url.netloc, + 'username': FLAGS.vmwareapi_host_password, + 'password': FLAGS.vmwareapi_host_password} + + def _create_dummy_vm_for_test(self, instance): + """ + Creates a dummy 1MB VM with default parameters for testing purpose + """ + return self._vmops._create_dummy_vm_for_test(instance) + + +class VMWareAPISession(object): + """ + Sets up a session with the ESX host and handles all the calls made to the + host + """ + + def __init__(self, host_ip, host_username, host_password, + api_retry_count, scheme="https"): + """ + Set the connection credentials + """ + self._host_ip = host_ip + self._host_username = host_username + self._host_password = host_password + self.api_retry_count = api_retry_count + self._scheme = scheme + self._session_id = None + self.vim = None + self._create_session() + + def _create_session(self): + """ + Creates a session with the ESX host + """ + while True: + try: + # Login and setup the session with the ESX host for making + # API calls + self.vim = vim.Vim(protocol=self._scheme, host=self._host_ip) + session = self.vim.Login( + self.vim.get_service_content().SessionManager, + userName=self._host_username, + password=self._host_password) + # Terminate the earlier session, if possible ( For the sake of + # preserving sessions as there is a limit to the number of + # sessions we can have ) + if self._session_id: + try: + self.vim.TerminateSession( + self.vim.get_service_content().SessionManager, + sessionId=[self._session_id]) + except Exception, excep: + LOG.exception(excep) + self._session_id = session.Key + return + except Exception, excep: + LOG.critical("In vmwareapi:_create_session, " + "got this exception: %s" % excep) + raise Exception(excep) + + def __del__(self): + """ + The Destructor. Logs-out the session. + """ + # Logout to avoid un-necessary increase in session count at the + # ESX host + try: + self.vim.Logout(self.vim.get_service_content().SessionManager) + except: + pass + + def _call_method(self, module, method, *args, **kwargs): + """ + Calls a method within the module specified with args provided + """ + args = list(args) + retry_count = 0 + exc = None + while True: + try: + if not isinstance(module, vim.Vim): + #If it is not the first try, then get the latest vim object + if retry_count > 0: + args = args[1:] + args = [self.vim] + args + retry_count += 1 + temp_module = module + + for method_elem in method.split("."): + temp_module = getattr(temp_module, method_elem) + + ret_val = temp_module(*args, **kwargs) + return ret_val + except vim.SessionFaultyException, excep: + # If it is a Session Fault Exception, it may point + # to a session gone bad. So we try re-creating a session + # and then proceeding ahead with the call. + exc = excep + self._create_session() + except vim.SessionOverLoadException, excep: + # For exceptions which may come because of session overload, + # we retry + exc = excep + except Exception, excep: + # If it is a proper exception, say not having furnished + # proper data in the SOAP call or the retry limit having + # exceeded, we raise the exception + exc = excep + break + # If retry count has been reached then break and + # raise the exception + if retry_count > self.api_retry_count: + break + time.sleep(TIME_BETWEEN_API_CALL_RETRIES) + + LOG.critical("In vmwareapi:_call_method, " + "got this exception: " % exc) + raise Exception(exc) + + def _get_vim(self): + """ + Gets the VIM object reference + """ + if self.vim is None: + self._create_session() + return self.vim + + def _wait_for_task(self, instance_id, task_ref): + """ + Return a Deferred that will give the result of the given task. + The task is polled until it completes. + """ + done = event.Event() + self.loop = utils.LoopingCall(self._poll_task, instance_id, task_ref, + done) + self.loop.start(FLAGS.vmwareapi_task_poll_interval, now=True) + ret_val = done.wait() + self.loop.stop() + return ret_val + + def _poll_task(self, instance_id, task_ref, done): + """ + Poll the given task, and fires the given Deferred if we + get a result. + """ + try: + task_info = self._call_method(vim_util, "get_dynamic_property", + task_ref, "Task", "info") + task_name = task_info.Name + action = dict( + instance_id=int(instance_id), + action=task_name[0:255], + error=None) + if task_info.State in ['queued', 'running']: + return + elif task_info.State == 'success': + LOG.info("Task [%s] %s status: success " % ( + task_name, + str(task_ref))) + done.send("success") + else: + error_info = str(task_info.Error.LocalizedMessage) + action["error"] = error_info + LOG.warn("Task [%s] %s status: error %s" % ( + task_name, + str(task_ref), + error_info)) + done.send_exception(Exception(error_info)) + db.instance_action_create(context.get_admin_context(), action) + except Exception, excep: + LOG.warn("In vmwareapi:_poll_task, Got this error %s" % excep) + done.send_exception(excep) diff --git a/nova/virt/vmwareapi_readme.rst b/nova/virt/vmwareapi_readme.rst new file mode 100644 index 000000000..4e722674b --- /dev/null +++ b/nova/virt/vmwareapi_readme.rst @@ -0,0 +1,72 @@ +.. + + Copyright (c) 2010 Citrix Systems, Inc. + Copyright 2010 OpenStack LLC. + + Licensed under the Apache License, Version 2.0 (the "License"); you may + not use this file except in compliance with the License. You may obtain + a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + License for the specific language governing permissions and limitations + under the License. + +VMWare ESX/ESXi Server Support for OpenStack Compute +==================================================== + +System Requirements +------------------- +Following software components are required for building the cloud using OpenStack on top of ESX/ESXi Server(s): +* OpenStack (Bexar Release) +* Glance Image service (Bexar Release) +* VMware ESX v4.1 or VMware ESXi(licensed) v4.1 + +VMware ESX Requirements +----------------------- +* ESX credentials with administration/root privileges +* Single local hard disk at the ESX host +* An ESX Virtual Machine Port Group (Bridge for Flat Networking) + +Python dependencies +------------------- +* ZSI-2.0 + +Configuration flags required for nova-compute +--------------------------------------------- +:: + --connection_type=vmwareapi + --vmwareapi_host_ip= + --vmwareapi_host_username= + --vmwareapi_host_password= + +Other flags +----------- +:: + --network_manager=nova.network.manager.FlatManager + --flat_network_bridge= + --image_service=nova.image.glance.GlanceImageService + --glance_host= + +FAQ +--- + +What type of disk images are supported? + + Only VMware VMDK's are currently supported and of that support is available only for thick disks, thin provisioned disks are not supported. + + +How is IP address information injected into the guest? + + IP address information is injected through 'machine.id' vmx parameter (equivalent to XenStore in XenServer). + This information can be retrived inside the guest using VMware tools. + + +What is the guest tool? + + The guest tool is a small python script that should be run either as a service or added to system startup. This script configures networking on the guest. + + -- cgit From 09d0e70ddf28914dc057cd04e8309499fb36fda6 Mon Sep 17 00:00:00 2001 From: sateesh Date: Thu, 17 Feb 2011 22:01:21 +0530 Subject: Block diagram for vmwareapi module --- nova/virt/vmwareapi_blockdiagram.jpg | Bin 0 -> 75363 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 nova/virt/vmwareapi_blockdiagram.jpg (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi_blockdiagram.jpg b/nova/virt/vmwareapi_blockdiagram.jpg new file mode 100644 index 000000000..1ae1fc8e0 Binary files /dev/null and b/nova/virt/vmwareapi_blockdiagram.jpg differ -- cgit From 441beee908d2534c4fa1d85523dbc87770efeb17 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Thu, 17 Feb 2011 16:54:42 +0000 Subject: Supporting networks with multiple PIFs. pep8 fixes unit tests passed --- nova/virt/xenapi/network_utils.py | 12 +++++------- nova/virt/xenapi/vmops.py | 11 ++++++----- 2 files changed, 11 insertions(+), 12 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py index 8f7806e6c..c4ee8a6be 100644 --- a/nova/virt/xenapi/network_utils.py +++ b/nova/virt/xenapi/network_utils.py @@ -28,10 +28,9 @@ class NetworkHelper(HelperBase): """ The class that wraps the helper methods together. """ - - + @classmethod - def find_network_with_name_label(cls,session,name_label): + def find_network_with_name_label(cls, session, name_label): networks = session.call_xenapi('network.get_by_name_label', name_label) if len(networks) == 1: return networks[0] @@ -39,9 +38,8 @@ class NetworkHelper(HelperBase): raise Exception(_('Found non-unique network' ' for name_label %s') % name_label) else: - return None - - + return None + @classmethod def find_network_with_bridge(cls, session, bridge): """Return the network on which the bridge is attached, if found.""" @@ -53,4 +51,4 @@ class NetworkHelper(HelperBase): raise Exception(_('Found non-unique network' ' for bridge %s') % bridge) else: - raise Exception(_('Found no network for bridge %s') % bridge) + raise Exception(_('Found no network for bridge %s') % bridge) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b5c5e082e..a0dbd1411 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -70,18 +70,19 @@ class VMOps(object): #this will return the bridge name in nova db bridge = db.network_get_by_instance(context.get_admin_context(), instance['id'])['bridge'] - + #this will return the appropriate network #TODO: avoid unnecessary call to find_network_with_bridge #when VLAN manager is being used (and not just use an if) - network_ref = None - try: + network_ref = None + try: network_ref = \ NetworkHelper.find_network_with_bridge(self._session, bridge) except: - #try to get name with name_label + #try to get name with name_label network_ref = \ - NetworkHelper.find_network_with_name_label(self._session,bridge) + NetworkHelper.find_network_with_name_label(self._session, + bridge) user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) -- cgit From ea4d21b546d9447bac50cf97a62c11129da12d21 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 17 Feb 2011 13:10:37 -0600 Subject: comments + Englilish, changed copyright in migration, removed network_get_all from db.api (vestigial) --- nova/virt/xenapi/vmops.py | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ea99ff626..842e08f22 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -151,6 +151,8 @@ class VMOps(object): % locals()) # NOTE(armando): Do we really need to do this in virt? + # NOTE(tr3buchet): not sure but wherever we do it, we need to call + # reset_network afterwards timer = utils.LoopingCall(f=None) def _wait_for_boot(): @@ -437,6 +439,10 @@ class VMOps(object): return 'http://fakeajaxconsole/fake_url' def reset_network(self, instance): + """ + Creates uuid arg to pass to make_agent_call and calls it. + + """ args = {'id': str(uuid.uuid4())} resp = self._make_agent_call('resetnetwork', instance, '', args) -- cgit From b1fe9a64143505235eb2e3dbe6a6c0966a85ae76 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 17 Feb 2011 14:10:08 -0600 Subject: Stop blowing away the ramdisk --- nova/virt/xenapi/vmops.py | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 13c13d0f6..17b91d27c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -234,7 +234,8 @@ class VMOps(object): return self def __exit__(self, type, value, traceback): - self.virt._destroy(self.instance, self.vm_ref, shutdown=False) + self.virt._destroy(self.instance, self.vm_ref, shutdown=False, + destroy_kernel_ramdisk=False) #TODO(sirp): Add quiesce and VSS locking support when Windows support # is added @@ -393,7 +394,7 @@ class VMOps(object): except self.XenAPI.Failure, exc: LOG.exception(exc) - def _destroy_vm(self, instance, vm): + def _destroy_vm(self, instance, vm, destroy_kernel_ramdisk): """Destroys a VM record """ try: kernel = None @@ -402,16 +403,18 @@ class VMOps(object): (kernel, ramdisk) = VMHelper.lookup_kernel_ramdisk( self._session, vm) task1 = self._session.call_xenapi('Async.VM.destroy', vm) - LOG.debug(_("Removing kernel/ramdisk files")) - fn = "remove_kernel_ramdisk" - args = {} - if kernel: - args['kernel-file'] = kernel - if ramdisk: - args['ramdisk-file'] = ramdisk - task2 = self._session.async_call_plugin('glance', fn, args) + if destroy_kernel_ramdisk: + LOG.debug(_("Removing kernel/ramdisk files")) + fn = "remove_kernel_ramdisk" + args = {} + if kernel: + args['kernel-file'] = kernel + if ramdisk: + args['ramdisk-file'] = ramdisk + task2 = self._session.async_call_plugin('glance', fn, args) self._session.wait_for_task(instance.id, task1) - self._session.wait_for_task(instance.id, task2) + if destroy_kernel_ramdisk: + self._session.wait_for_task(instance.id, task2) LOG.debug(_("kernel/ramdisk files removed")) except self.XenAPI.Failure, exc: LOG.exception(exc) @@ -426,7 +429,7 @@ class VMOps(object): vm = VMHelper.lookup(self._session, instance.name) return self._destroy(instance, vm, shutdown=True) - def _destroy(self, instance, vm, shutdown=True): + def _destroy(self, instance, vm, shutdown=True, destroy_kernel_ramdisk=True): """ Destroys VM instance by performing: @@ -443,7 +446,7 @@ class VMOps(object): self._shutdown(instance, vm) self._destroy_vdis(instance, vm) - self._destroy_vm(instance, vm) + self._destroy_vm(instance, vm, destroy_kernel_ramdisk) def _wait_with_callback(self, instance_id, task, callback): ret = None -- cgit From 3dd6e369c0aa2e3092eaa32a6b04cbba712ba5ad Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 17 Feb 2011 14:23:20 -0600 Subject: Move the ramdisk logging stuff --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 17b91d27c..f7e434300 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -412,10 +412,10 @@ class VMOps(object): if ramdisk: args['ramdisk-file'] = ramdisk task2 = self._session.async_call_plugin('glance', fn, args) + LOG.debug(_("kernel/ramdisk files removed")) self._session.wait_for_task(instance.id, task1) if destroy_kernel_ramdisk: self._session.wait_for_task(instance.id, task2) - LOG.debug(_("kernel/ramdisk files removed")) except self.XenAPI.Failure, exc: LOG.exception(exc) -- cgit From 8da339d53b4039c3a8e5e8a15ccf1434eeda5fa2 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 17 Feb 2011 15:05:19 -0600 Subject: Fixed unit test --- nova/virt/xenapi/vm_utils.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 339cecd40..7031f2f82 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -141,7 +141,8 @@ class VMHelper(HelperBase): @classmethod def ensure_free_mem(cls, session, instance): - instance_type = instance_types.INSTANCE_TYPES[instance.instance_type] + instance_type = instance_types.get_instance_type( + instance.instance_type) mem = long(instance_type['memory_mb']) * 1024 * 1024 #get free memory from host host = session.get_xenapi_host() -- cgit From 0e3c86dcdc49890eecaa2d1ea64c0012e569682f Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 17 Feb 2011 22:07:00 +0100 Subject: Use a semaphore to ensure we don't run more than one iptables-restore at a time. --- nova/virt/libvirt_conn.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4e0fd106f..7548fff63 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -46,6 +46,7 @@ from xml.dom import minidom from eventlet import greenthread from eventlet import event +from eventlet import semaphore from eventlet import tpool import IPy @@ -63,6 +64,7 @@ from nova.compute import power_state from nova.virt import disk from nova.virt import images +libvirt_semaphore = semaphore.Semaphore() libvirt = None libxml2 = None Template = None @@ -1237,17 +1239,19 @@ class IptablesFirewallDriver(FirewallDriver): self.apply_ruleset() def apply_ruleset(self): - current_filter, _ = self.execute('sudo iptables-save -t filter') - current_lines = current_filter.split('\n') - new_filter = self.modify_rules(current_lines, 4) - self.execute('sudo iptables-restore', - process_input='\n'.join(new_filter)) - if(FLAGS.use_ipv6): - current_filter, _ = self.execute('sudo ip6tables-save -t filter') + with libvirt_semaphore: + current_filter, _ = self.execute('sudo iptables-save -t filter') current_lines = current_filter.split('\n') - new_filter = self.modify_rules(current_lines, 6) - self.execute('sudo ip6tables-restore', + new_filter = self.modify_rules(current_lines, 4) + self.execute('sudo iptables-restore', process_input='\n'.join(new_filter)) + if(FLAGS.use_ipv6): + current_filter, _ = self.execute('sudo ip6tables-save ' + '-t filter') + current_lines = current_filter.split('\n') + new_filter = self.modify_rules(current_lines, 6) + self.execute('sudo ip6tables-restore', + process_input='\n'.join(new_filter)) def modify_rules(self, current_lines, ip_version=4): ctxt = context.get_admin_context() -- cgit From f0d58ea141116ccfd1c977b0f3e5fc669c0ea8a9 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 17 Feb 2011 18:06:34 -0600 Subject: moved inject network info to a function which accepts only instance, and call it from reset network --- nova/virt/xenapi/vmops.py | 96 +++++++++++++++++++++++++++-------------------- 1 file changed, 55 insertions(+), 41 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 842e08f22..d1ef95c6c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -104,46 +104,6 @@ class VMOps(object): instance, kernel, ramdisk, pv_kernel) VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) - # write network info - admin_context = context.get_admin_context() - - # TODO(tr3buchet) - remove comment in multi-nic - # I've decided to go ahead and consider multiple IPs and networks - # at this stage even though they aren't implemented because these will - # be needed for multi-nic and there was no sense writing it for single - # network/single IP and then having to turn around and re-write it - IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) - for network in db.network_get_all_by_instance(admin_context, - instance['id']): - network_IPs = [ip for ip in IPs if ip.network_id == network.id] - - def ip_dict(ip): - return {'netmask': network['netmask'], - 'enabled': '1', - 'ip': ip.address} - - mac_id = instance.mac_address.replace(':', '') - location = 'vm-data/networking/%s' % mac_id - mapping = {'label': network['label'], - 'gateway': network['gateway'], - 'mac': instance.mac_address, - 'dns': [network['dns']], - 'ips': [ip_dict(ip) for ip in network_IPs]} - self.write_to_param_xenstore(vm_ref, {location: mapping}) - - # TODO(tr3buchet) - remove comment in multi-nic - # this bit here about creating the vifs will be updated - # in multi-nic to handle multiple IPs on the same network - # and multiple networks - # for now it works as there is only one of each - bridge = network['bridge'] - network_ref = \ - NetworkHelper.find_network_with_bridge(self._session, bridge) - - if network_ref: - VMHelper.create_vif(self._session, vm_ref, - network_ref, instance.mac_address) - LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) instance_name = instance.name @@ -174,7 +134,7 @@ class VMOps(object): timer.f = _wait_for_boot - # call reset networking + # call to reset network to inject network info and configure self.reset_network(instance) return timer.start(interval=0.5, now=True) @@ -438,11 +398,65 @@ class VMOps(object): # TODO: implement this! return 'http://fakeajaxconsole/fake_url' + def inject_network_info(self, instance): + """ + Generate the network info and make calls to place it into the + xenstore and the xenstore param list + + """ + # TODO(tr3buchet) - remove comment in multi-nic + # I've decided to go ahead and consider multiple IPs and networks + # at this stage even though they aren't implemented because these will + # be needed for multi-nic and there was no sense writing it for single + # network/single IP and then having to turn around and re-write it + vm_opaque_ref = self._get_vm_opaque_ref(instance.id) + logging.debug(_("injecting network info to xenstore for vm: |%s|"), + vm_opaque_ref) + admin_context = context.get_admin_context() + IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) + for network in db.network_get_all_by_instance(admin_context, + instance['id']): + network_IPs = [ip for ip in IPs if ip.network_id == network.id] + + def ip_dict(ip): + return {'netmask': network['netmask'], + 'enabled': '1', + 'ip': ip.address} + + mac_id = instance.mac_address.replace(':', '') + location = 'vm-data/networking/%s' % mac_id + mapping = {'label': network['label'], + 'gateway': network['gateway'], + 'mac': instance.mac_address, + 'dns': [network['dns']], + 'ips': [ip_dict(ip) for ip in network_IPs]} + self.write_to_param_xenstore(vm_opaque_ref, {location: mapping}) + try: + self.write_to_xenstore(vm_opaque_ref, location, + mapping['location']) + except KeyError: + # catch KeyError for domid if instance isn't running + pass + + # TODO(tr3buchet) - remove comment in multi-nic + # this bit here about creating the vifs will be updated + # in multi-nic to handle multiple IPs on the same network + # and multiple networks + # for now it works as there is only one of each + bridge = network['bridge'] + network_ref = \ + NetworkHelper.find_network_with_bridge(self._session, bridge) + + if network_ref: + VMHelper.create_vif(self._session, vm_opaque_ref, + network_ref, instance.mac_address) + def reset_network(self, instance): """ Creates uuid arg to pass to make_agent_call and calls it. """ + self.inject_network_info(instance) args = {'id': str(uuid.uuid4())} resp = self._make_agent_call('resetnetwork', instance, '', args) -- cgit From 4b51ec3e9bca7421c66816c77c43396e51e68ea6 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 17 Feb 2011 23:09:06 -0600 Subject: Tests --- nova/virt/fake.py | 13 +++++++++++++ nova/virt/xenapi_conn.py | 8 -------- 2 files changed, 13 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index ff5e22603..da86df6d4 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -176,6 +176,19 @@ class FakeConnection(object): """ pass + def migrate_disk_and_power_off(self, instance, dest): + """ + Transfers the disk of a running instance in multiple phases, turning + off the instance before the end. + """ + pass + + def attach_disk(self, instance, disk_info): + """ + Attaches the disk to an instance given the metadata disk_info + """ + pass + def pause(self, instance, callback): """ Pause the specified instance. diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index aafd836e2..be018b47f 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -184,14 +184,6 @@ class XenAPIConnection(object): """Unpause paused VM instance""" self._vmops.unpause(instance, callback) - def power_off(self, instance): - """Shuts down a running VM instance""" - self._vmops._shutdown(instance, method='clean') - - def power_on(self, instance): - """powers on a powered off VM instance""" - self._vmops.power_on(instance) - def migrate_disk_and_power_off(self, instance, dest): """Transfers the VHD of a running instance to another host, then shuts off the instance copies over the COW disk""" -- cgit From d88d74c9a0a28e0ebd6cedf694753b9ee9decdac Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Fri, 18 Feb 2011 14:15:04 +0900 Subject: fixed based on reviewer's comment. 1. erase wrapper function(remove/exists/mktempfile) from nova.utils. 2. nova-manage service describeresource(->describe_resource) 3. nova-manage service updateresource(->update_resource) 4. erase "my mistake print" statement Additional changes are made at: 1. nova.image.s3.show 2. nova.compute.api.create that's because instances cannot launched without this changes. --- nova/virt/disk.py | 1 - nova/virt/libvirt_conn.py | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index ec4acc452..c5565abfa 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -112,7 +112,6 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): def _link_device(image, nbd): """Link image to device using loopback or nbd""" - print '_link_device:0:', nbd, '::', image if nbd: device = _allocate_device() utils.execute('sudo qemu-nbd -c %s %s' % (device, image)) diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9b7a9ddbe..579c4593e 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -977,7 +977,7 @@ class LibvirtConnection(object): """ Update compute manager resource info on Service table. This method is called when nova-coompute launches, and - whenever admin executes "nova-manage service updateresource". + whenever admin executes "nova-manage service update_resource". """ try: -- cgit From 671766cb4ada59b0e575b395b5afff82950ddb76 Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Fri, 18 Feb 2011 06:03:15 +0000 Subject: Resize compute tests --- nova/virt/fake.py | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index da86df6d4..9106ebf03 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -139,6 +139,12 @@ class FakeConnection(object): """ pass + def get_host_ip_addr(self): + """ + Retrieves the IP address of the dom0 + """ + pass + def resize(self, instance, flavor): """ Resizes/Migrates the specified instance. -- cgit From bb5624258200f027320327a38c524c389979c97a Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Fri, 18 Feb 2011 19:04:57 +0000 Subject: Resize compute tests --- nova/virt/xenapi/fake.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 018d0dcd3..e1ae03e70 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -401,7 +401,7 @@ class SessionBase(object): field in _db_content[cls][ref]): return _db_content[cls][ref][field] - LOG.debuug(_('Raising NotImplemented')) + LOG.debug(_('Raising NotImplemented')) raise NotImplementedError( _('xenapi.fake does not have an implementation for %s or it has ' 'been called with the wrong number of arguments') % name) -- cgit From 5812a95736b9a16733b99700e8664dd29ae34def Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Fri, 18 Feb 2011 22:10:06 +0100 Subject: Introduce IptablesManager in linux_net. Port every use of iptables in linux_net to it. --- nova/virt/libvirt_conn.py | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7548fff63..11b3acbf6 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -64,7 +64,6 @@ from nova.compute import power_state from nova.virt import disk from nova.virt import images -libvirt_semaphore = semaphore.Semaphore() libvirt = None libxml2 = None Template = None @@ -1239,19 +1238,22 @@ class IptablesFirewallDriver(FirewallDriver): self.apply_ruleset() def apply_ruleset(self): - with libvirt_semaphore: - current_filter, _ = self.execute('sudo iptables-save -t filter') + current_filter, _ = self.execute('sudo iptables-save -t filter', + attempts=5) + current_lines = current_filter.split('\n') + new_filter = self.modify_rules(current_lines, 4) + self.execute('sudo iptables-restore', + process_input='\n'.join(new_filter), + attempts=5) + if(FLAGS.use_ipv6): + current_filter, _ = self.execute('sudo ip6tables-save ' + '-t filter', + attempts=5) current_lines = current_filter.split('\n') - new_filter = self.modify_rules(current_lines, 4) - self.execute('sudo iptables-restore', - process_input='\n'.join(new_filter)) - if(FLAGS.use_ipv6): - current_filter, _ = self.execute('sudo ip6tables-save ' - '-t filter') - current_lines = current_filter.split('\n') - new_filter = self.modify_rules(current_lines, 6) - self.execute('sudo ip6tables-restore', - process_input='\n'.join(new_filter)) + new_filter = self.modify_rules(current_lines, 6) + self.execute('sudo ip6tables-restore', + process_input='\n'.join(new_filter), + attempts=5) def modify_rules(self, current_lines, ip_version=4): ctxt = context.get_admin_context() -- cgit From 62b3eb71384581e900b061e65caa6418c4452fa9 Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Fri, 18 Feb 2011 21:37:57 +0000 Subject: XenAPI tests --- nova/virt/xenapi/fake.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index e1ae03e70..ba12d4d3a 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -290,6 +290,9 @@ class SessionBase(object): #Always return 12GB available return 12 * 1024 * 1024 * 1024 + def host_call_plugin(*args): + return 'herp' + def xenapi_request(self, methodname, params): if methodname.startswith('login'): self._login(methodname, params) -- cgit From 8916442e7f2920938a317777de71f75faf463005 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Fri, 18 Feb 2011 21:42:04 +0000 Subject: Typo fix --- nova/virt/xenapi/vm_utils.py | 2 ++ nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 9027d58c4..88a205d2f 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -451,6 +451,8 @@ class VMHelper(HelperBase): else: return ImageType.DISK_RAW + # FIXME(sirp): can we unify the ImageService and xenapi_image_service + # abstractions? if FLAGS.xenapi_image_service == 'glance': image_type = determine_from_glance() else: diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 8d1c79c0b..09abd5861 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -394,7 +394,7 @@ class VMOps(object): """ Three situations can occur: - 1. We have netiher a ramdisk or a kernel, in which case we are a + 1. We have neither a ramdisk nor a kernel, in which case we are a RAW image and can omit this step 2. We have one or the other, in which case, we should flag as an -- cgit From fa29dc0433384d5aa47f5ac069a8dc650e23ccae Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Fri, 18 Feb 2011 15:48:49 -0600 Subject: moved creating vifs to its own function, moved inject network to its own function --- nova/virt/xenapi/vmops.py | 30 ++++++++++++++++++++++-------- 1 file changed, 22 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index d1ef95c6c..76b88a8bd 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -135,6 +135,8 @@ class VMOps(object): timer.f = _wait_for_boot # call to reset network to inject network info and configure + networks = self.inject_network_info(instance) + self.create_vifs(instance, networks) self.reset_network(instance) return timer.start(interval=0.5, now=True) @@ -414,8 +416,9 @@ class VMOps(object): vm_opaque_ref) admin_context = context.get_admin_context() IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) - for network in db.network_get_all_by_instance(admin_context, - instance['id']): + networks = db.network_get_all_by_instance(admin_context, + instance['id']) + for network in networks: network_IPs = [ip for ip in IPs if ip.network_id == network.id] def ip_dict(ip): @@ -438,11 +441,23 @@ class VMOps(object): # catch KeyError for domid if instance isn't running pass - # TODO(tr3buchet) - remove comment in multi-nic - # this bit here about creating the vifs will be updated - # in multi-nic to handle multiple IPs on the same network - # and multiple networks - # for now it works as there is only one of each + return networks + + def create_vifs(self, instance, networks=None): + """ + Creates vifs for an instance + + """ + logging.debug(_("creating vif(s) for vm: |%s|"), vm_opaque_ref) + if networks is None: + networks = db.network_get_all_by_instance(admin_context, + instance['id']) + # TODO(tr3buchet) - remove comment in multi-nic + # this bit here about creating the vifs will be updated + # in multi-nic to handle multiple IPs on the same network + # and multiple networks + # for now it works as there is only one of each + for network in networks: bridge = network['bridge'] network_ref = \ NetworkHelper.find_network_with_bridge(self._session, bridge) @@ -456,7 +471,6 @@ class VMOps(object): Creates uuid arg to pass to make_agent_call and calls it. """ - self.inject_network_info(instance) args = {'id': str(uuid.uuid4())} resp = self._make_agent_call('resetnetwork', instance, '', args) -- cgit From a43c5929de7ebf58eb9ecb8416ce3cf4194c176a Mon Sep 17 00:00:00 2001 From: Cerberus Date: Fri, 18 Feb 2011 16:13:34 -0600 Subject: Pep8 cleanup --- nova/virt/xenapi/vm_utils.py | 13 +++++-------- nova/virt/xenapi/vmops.py | 5 +++-- nova/virt/xenapi_conn.py | 6 +++--- 3 files changed, 11 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 91e7339b1..436c88023 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -256,21 +256,18 @@ class VMHelper(HelperBase): else: num_vdis = len(vdi_refs) if num_vdis != 1: - raise Exception(_("Unexpected number of VDIs (%(num_vdis)s) found" + raise Exception( + _("Unexpected number of VDIs (%(num_vdis)s) found" " for VM %(vm_ref)s") % locals()) vdi_ref = vdi_refs[0] vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref) return vdi_ref, vdi_rec - - - @classmethod def create_snapshot(cls, session, instance_id, vm_ref, label): """ Creates Snapshot (Template) VM, Snapshot VBD, Snapshot VDI, - Snapshot VHD - """ + Snapshot VHD """ #TODO(sirp): Add quiesce and VSS locking support when Windows support # is added LOG.debug(_("Snapshotting VM %(vm_ref)s with label '%(label)s'...") @@ -284,7 +281,7 @@ class VMHelper(HelperBase): task = session.call_xenapi('Async.VM.snapshot', vm_ref, label) template_vm_ref = session.wait_for_task(instance_id, task) - template_vdi_rec = cls.get_vdi_for_vm_safely(session, + template_vdi_rec = cls.get_vdi_for_vm_safely(session, template_vm_ref)[1] template_vdi_uuid = template_vdi_rec["uuid"] @@ -299,7 +296,7 @@ class VMHelper(HelperBase): @classmethod def get_sr(cls, session, sr_label='slices'): - """ Finds the SR named by the given name label and returns + """ Finds the SR named by the given name label and returns the UUID """ return session.call_xenapi('SR.get_by_name_label', sr_label)[0] diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 552c2ddd1..d457f2e3f 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -345,7 +345,7 @@ class VMOps(object): 'new_base_copy_uuid': new_base_copy_uuid, 'new_cow_uuid': new_cow_uuid, } - task = self._session.async_call_plugin('migration', + task = self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) self._session.wait_for_task(instance.id, task) @@ -469,7 +469,8 @@ class VMOps(object): vm = VMHelper.lookup(self._session, instance.name) return self._destroy(instance, vm, shutdown=True) - def _destroy(self, instance, vm, shutdown=True, destroy_kernel_ramdisk=True): + def _destroy(self, instance, vm, shutdown=True, + destroy_kernel_ramdisk=True): """ Destroys VM instance by performing: diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index be018b47f..e1c5dcc7c 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -192,7 +192,7 @@ class XenAPIConnection(object): def attach_disk(self, instance, disk_info): """Moves the copied VDIs into the SR""" return self._vmops.attach_disk(instance, disk_info) - + def suspend(self, instance, callback): """suspend the specified instance""" self._vmops.suspend(instance, callback) @@ -220,9 +220,9 @@ class XenAPIConnection(object): def get_ajax_console(self, instance): """Return link to instance's ajax console""" return self._vmops.get_ajax_console(instance) - + def get_host_ip_addr(self): - xs_url = urlparse.urlparse(FLAGS.xenapi_connection_url) + xs_url = urlparse.urlparse(FLAGS.xenapi_connection_url) return xs_url.netloc def attach_volume(self, instance_name, device_path, mountpoint): -- cgit From eefc8938d8a8010052affab9a5c0d010778d9780 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Fri, 18 Feb 2011 22:25:19 +0000 Subject: Changing type -> image_type --- nova/virt/xenapi/vm_utils.py | 44 +++++++++++++++++++++++++------------------- 1 file changed, 25 insertions(+), 19 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 88a205d2f..2114bfa42 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -305,9 +305,10 @@ class VMHelper(HelperBase): session.wait_for_task(instance_id, task) @classmethod - def fetch_image(cls, session, instance_id, image, user, project, type): + def fetch_image(cls, session, instance_id, image, user, project, + image_type): """ - type is interpreted as an ImageType instance + image_type is interpreted as an ImageType instance Related flags: xenapi_image_service = ['glance', 'objectstore'] glance_address = 'address for glance services' @@ -317,14 +318,15 @@ class VMHelper(HelperBase): if FLAGS.xenapi_image_service == 'glance': return cls._fetch_image_glance(session, instance_id, image, - access, type) + access, image_type) else: return cls._fetch_image_objectstore(session, instance_id, image, - access, user.secret, type) + access, user.secret, + image_type) @classmethod def _fetch_image_glance_vhd(cls, session, instance_id, image, access, - type): + image_type): LOG.debug(_("Asking xapi to fetch vhd image %(image)s") % locals()) @@ -358,7 +360,7 @@ class VMHelper(HelperBase): @classmethod def _fetch_image_glance_disk(cls, session, instance_id, image, access, - type): + image_type): """Fetch the image from Glance NOTE: @@ -378,7 +380,7 @@ class VMHelper(HelperBase): vdi_size = virtual_size LOG.debug(_("Size for image %(image)s:%(virtual_size)d") % locals()) - if type == ImageType.DISK: + if image_type == ImageType.DISK: # Make room for MBR. vdi_size += MBR_SIZE_BYTES @@ -387,9 +389,9 @@ class VMHelper(HelperBase): with_vdi_attached_here(session, vdi, False, lambda dev: - _stream_disk(dev, type, + _stream_disk(dev, image_type, virtual_size, image_file)) - if (type == ImageType.KERNEL_RAMDISK): + if image_type == ImageType.KERNEL_RAMDISK: #we need to invoke a plugin for copying VDI's #content into proper path LOG.debug(_("Copying VDI %s to /boot/guest on dom0"), vdi) @@ -462,29 +464,33 @@ class VMHelper(HelperBase): return image_type @classmethod - def _fetch_image_glance(cls, session, instance_id, image, access, type): - if type == ImageType.DISK_VHD: + def _fetch_image_glance(cls, session, instance_id, image, access, + image_type): + if image_type == ImageType.DISK_VHD: return cls._fetch_image_glance_vhd( - session, instance_id, image, access, type) + session, instance_id, image, access, image_type) else: return cls._fetch_image_glance_disk( - session, instance_id, image, access, type) + session, instance_id, image, access, image_type) @classmethod def _fetch_image_objectstore(cls, session, instance_id, image, access, - secret, type): + secret, image_type): url = images.image_url(image) LOG.debug(_("Asking xapi to fetch %(url)s as %(access)s") % locals()) - fn = (type != ImageType.KERNEL_RAMDISK) and 'get_vdi' or 'get_kernel' + if image_type == ImageType.KERNEL_RAMDISK: + fn = 'get_kernel' + else: + fn = 'get_vdi' args = {} args['src_url'] = url args['username'] = access args['password'] = secret args['add_partition'] = 'false' args['raw'] = 'false' - if type != ImageType.KERNEL_RAMDISK: + if image_type != ImageType.KERNEL_RAMDISK: args['add_partition'] = 'true' - if type == ImageType.DISK_RAW: + if image_type == ImageType.DISK_RAW: args['raw'] = 'true' task = session.async_call_plugin('objectstore', fn, args) uuid = session.wait_for_task(instance_id, task) @@ -857,9 +863,9 @@ def get_this_vm_ref(session): return session.get_xenapi().VM.get_by_uuid(get_this_vm_uuid()) -def _stream_disk(dev, type, virtual_size, image_file): +def _stream_disk(dev, image_type, virtual_size, image_file): offset = 0 - if type == ImageType.DISK: + if image_type == ImageType.DISK: offset = MBR_SIZE_BYTES _write_partition(virtual_size, dev) -- cgit From e369f2842446876505ce528c5bb56a3d41215f8f Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Fri, 18 Feb 2011 16:42:26 -0600 Subject: added admin api call for injecting network info, added api test for inject network info --- nova/virt/xenapi_conn.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 2720d175f..f72a12380 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -192,6 +192,10 @@ class XenAPIConnection(object): """reset networking for specified instance""" self._vmops.reset_network(instance) + def inject_network_info(self, instance): + """inject network info for specified instance""" + self._vmops.inject_network_info(instance) + def get_info(self, instance_id): """Return data about VM instance""" return self._vmops.get_info(instance_id) -- cgit From cfd6d4e403dcb2405cd7ff48bad3083a02159d2c Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Sat, 19 Feb 2011 00:14:08 +0100 Subject: Port libvirt_conn.IptablesDriver over to use linux_net.IptablesManager --- nova/virt/libvirt_conn.py | 215 ++++++++++++++++++++-------------------------- 1 file changed, 94 insertions(+), 121 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 11b3acbf6..976ccaca5 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -57,7 +57,6 @@ from nova import exception from nova import flags from nova import log as logging from nova import utils -#from nova.api import context from nova.auth import manager from nova.compute import instance_types from nova.compute import power_state @@ -1207,10 +1206,14 @@ class NWFilterFirewall(FirewallDriver): class IptablesFirewallDriver(FirewallDriver): def __init__(self, execute=None, **kwargs): - self.execute = execute or utils.execute + from nova.network import linux_net + self.iptables = linux_net.iptables_manager self.instances = {} self.nwfilter = NWFilterFirewall(kwargs['get_connection']) + self.iptables.ipv4['filter'].add_chain('sg-fallback') + self.iptables.ipv4['filter'].add_rule('sg-fallback', '-j DROP') + def setup_basic_filtering(self, instance): """Use NWFilter from libvirt for this.""" return self.nwfilter.setup_basic_filtering(instance) @@ -1226,124 +1229,92 @@ class IptablesFirewallDriver(FirewallDriver): LOG.info(_('Attempted to unfilter instance %s which is not ' 'filtered'), instance['id']) - def add_instance(self, instance): + def prepare_instance_filter(self, instance): self.instances[instance['id']] = instance + chain_name = self._instance_chain_name(instance) + + self.iptables.ipv4['filter'].add_chain(chain_name) + ipv4_address = self._ip_for_instance(instance) + self.iptables.ipv4['filter'].add_rule('local', + '-d %s -j $%s' % + (ipv4_address, chain_name)) + + if FLAGS.use_ipv6: + self.iptables.ipv6['filter'].add_chain(chain_name) + ipv6_address = self._ip_for_instance_v6(instance) + self.iptables.ipv4['filter'].add_rule('local', + '-d %s -j $%s' % + (ipv6_address, + chain_name)) + + ipv4_rules, ipv6_rules = self.instance_rules(instance) + + for rule in ipv4_rules: + self.iptables.ipv4['filter'].add_rule(chain_name, rule) + + if FLAGS.use_ipv6: + for rule in ipv6_rules: + self.iptables.ipv6['filter'].add_rule(chain_name, rule) + + self.iptables.apply() + def unfilter_instance(self, instance): - self.remove_instance(instance) - self.apply_ruleset() + chain_name = self._instance_chain_name(instance) - def prepare_instance_filter(self, instance): - self.add_instance(instance) - self.apply_ruleset() + self.iptables.ipv4['filter'].remove_chain(chain_name) + if FLAGS.use_ipv6: + self.iptables.ipv6['filter'].remove_chain(chain_name) - def apply_ruleset(self): - current_filter, _ = self.execute('sudo iptables-save -t filter', - attempts=5) - current_lines = current_filter.split('\n') - new_filter = self.modify_rules(current_lines, 4) - self.execute('sudo iptables-restore', - process_input='\n'.join(new_filter), - attempts=5) - if(FLAGS.use_ipv6): - current_filter, _ = self.execute('sudo ip6tables-save ' - '-t filter', - attempts=5) - current_lines = current_filter.split('\n') - new_filter = self.modify_rules(current_lines, 6) - self.execute('sudo ip6tables-restore', - process_input='\n'.join(new_filter), - attempts=5) - - def modify_rules(self, current_lines, ip_version=4): + self.iptables.apply() + + + def instance_rules(self, instance): ctxt = context.get_admin_context() - # Remove any trace of nova rules. - new_filter = filter(lambda l: 'nova-' not in l, current_lines) - - seen_chains = False - for rules_index in range(len(new_filter)): - if not seen_chains: - if new_filter[rules_index].startswith(':'): - seen_chains = True - elif seen_chains == 1: - if not new_filter[rules_index].startswith(':'): - break - our_chains = [':nova-fallback - [0:0]'] - our_rules = ['-A nova-fallback -j DROP'] - - our_chains += [':nova-local - [0:0]'] - our_rules += ['-A FORWARD -j nova-local'] - our_rules += ['-A OUTPUT -j nova-local'] - - security_groups = {} - # Add our chains - # First, we add instance chains and rules - for instance_id in self.instances: - instance = self.instances[instance_id] - chain_name = self._instance_chain_name(instance) - if(ip_version == 4): - ip_address = self._ip_for_instance(instance) - elif(ip_version == 6): - ip_address = self._ip_for_instance_v6(instance) - - our_chains += [':%s - [0:0]' % chain_name] - - # Jump to the per-instance chain - our_rules += ['-A nova-local -d %s -j %s' % (ip_address, - chain_name)] - - # Always drop invalid packets - our_rules += ['-A %s -m state --state ' - 'INVALID -j DROP' % (chain_name,)] - - # Allow established connections - our_rules += ['-A %s -m state --state ' - 'ESTABLISHED,RELATED -j ACCEPT' % (chain_name,)] - - # Jump to each security group chain in turn - for security_group in \ - db.security_group_get_by_instance(ctxt, - instance['id']): - security_groups[security_group['id']] = security_group - - sg_chain_name = self._security_group_chain_name( - security_group['id']) + ipv4_rules = [] + ipv6_rules = [] - our_rules += ['-A %s -j %s' % (chain_name, sg_chain_name)] - - if(ip_version == 4): - # Allow DHCP responses - dhcp_server = self._dhcp_server_for_instance(instance) - our_rules += ['-A %s -s %s -p udp --sport 67 --dport 68 ' - '-j ACCEPT ' % (chain_name, dhcp_server)] - #Allow project network traffic - if (FLAGS.allow_project_net_traffic): - cidr = self._project_cidr_for_instance(instance) - our_rules += ['-A %s -s %s -j ACCEPT' % (chain_name, cidr)] - elif(ip_version == 6): - # Allow RA responses - ra_server = self._ra_server_for_instance(instance) - if ra_server: - our_rules += ['-A %s -s %s -p icmpv6 -j ACCEPT' % - (chain_name, ra_server + "/128")] - #Allow project network traffic - if (FLAGS.allow_project_net_traffic): - cidrv6 = self._project_cidrv6_for_instance(instance) - our_rules += ['-A %s -s %s -j ACCEPT' % - (chain_name, cidrv6)] - - # If nothing matches, jump to the fallback chain - our_rules += ['-A %s -j nova-fallback' % (chain_name,)] + # Always drop invalid packets + ipv4_rules += ['-m state --state ' 'INVALID -j DROP'] + ipv6_rules += ['-m state --state ' 'INVALID -j DROP'] - # then, security group chains and rules - for security_group_id in security_groups: - chain_name = self._security_group_chain_name(security_group_id) - our_chains += [':%s - [0:0]' % chain_name] + # Allow established connections + ipv4_rules += ['-m state --state ESTABLISHED,RELATED -j ACCEPT'] + ipv6_rules += ['-m state --state ESTABLISHED,RELATED -j ACCEPT'] + + dhcp_server = self._dhcp_server_for_instance(instance) + ipv4_rules += ['-s %s -p udp --sport 67 --dport 68 ' + '-j ACCEPT' % (dhcp_server,)] + + #Allow project network traffic + if FLAGS.allow_project_net_traffic: + cidr = self._project_cidr_for_instance(instance) + ipv4_rules += ['-s %s -j ACCEPT' % (cidr,)] + + # We wrap these in FLAGS.use_ipv6 because they might cause + # a DB lookup. The other ones are just list operations, so + # they're not worth the clutter. + if FLAGS.use_ipv6: + # Allow RA responses + ra_server = self._ra_server_for_instance(instance) + if ra_server: + ipv6_rules += ['-s %s/128 -p icmpv6 -j ACCEPT' % (ra_server,)] - rules = \ - db.security_group_rule_get_by_security_group(ctxt, - security_group_id) + #Allow project network traffic + if FLAGS.allow_project_net_traffic: + cidrv6 = self._project_cidrv6_for_instance(instance) + ipv6_rules += ['-s %s -j ACCEPT' % (cidrv6,)] + + + security_groups = db.security_group_get_by_instance(ctxt, + instance['id']) + + + # then, security group chains and rules + for security_group in security_groups: + rules = db.security_group_rule_get_by_security_group(ctxt, + security_group['id']) for rule in rules: logging.info('%r', rule) @@ -1354,14 +1325,16 @@ class IptablesFirewallDriver(FirewallDriver): continue version = _get_ip_version(rule.cidr) - if version != ip_version: - continue + if version == 4: + rules = ipv4_rules + else: + rules = ipv6_rules protocol = rule.protocol if version == 6 and rule.protocol == 'icmp': protocol = 'icmpv6' - args = ['-A', chain_name, '-p', protocol, '-s', rule.cidr] + args = ['-p', protocol, '-s', rule.cidr] if rule.protocol in ['udp', 'tcp']: if rule.from_port == rule.to_port: @@ -1382,20 +1355,20 @@ class IptablesFirewallDriver(FirewallDriver): icmp_type_arg += '/%s' % icmp_code if icmp_type_arg: - if(ip_version == 4): + if version == 4: args += ['-m', 'icmp', '--icmp-type', icmp_type_arg] - elif(ip_version == 6): + elif version == 6: args += ['-m', 'icmp6', '--icmpv6-type', icmp_type_arg] args += ['-j ACCEPT'] - our_rules += [' '.join(args)] + rules += [' '.join(args)] + + ipv4_rules += ['-j $fallback'] + ipv6_rules += ['-j $fallback'] - new_filter[rules_index:rules_index] = our_rules - new_filter[rules_index:rules_index] = our_chains - logging.info('new_filter: %s', '\n'.join(new_filter)) - return new_filter + return ipv4_rules, ipv6_rules def refresh_security_group_members(self, security_group): pass @@ -1407,7 +1380,7 @@ class IptablesFirewallDriver(FirewallDriver): return 'nova-sg-%s' % (security_group_id,) def _instance_chain_name(self, instance): - return 'nova-inst-%s' % (instance['id'],) + return 'inst-%s' % (instance['id'],) def _ip_for_instance(self, instance): return db.instance_get_fixed_address(context.get_admin_context(), -- cgit From 23729c543350ce4ce563077522f18d0bedd1e61b Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Sat, 19 Feb 2011 00:36:34 +0100 Subject: Security group fallback is named sg-fallback. --- nova/virt/libvirt_conn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 976ccaca5..0ddf889a1 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1365,8 +1365,8 @@ class IptablesFirewallDriver(FirewallDriver): args += ['-j ACCEPT'] rules += [' '.join(args)] - ipv4_rules += ['-j $fallback'] - ipv6_rules += ['-j $fallback'] + ipv4_rules += ['-j $sg-fallback'] + ipv6_rules += ['-j $sg-fallback'] return ipv4_rules, ipv6_rules -- cgit From e729c49543c5acf354b154a3e2d9fd76a2f7da35 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Mon, 21 Feb 2011 09:17:33 +0100 Subject: Fix refresh sec groups. --- nova/virt/libvirt_conn.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0ddf889a1..3faf01f4b 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1231,7 +1231,10 @@ class IptablesFirewallDriver(FirewallDriver): def prepare_instance_filter(self, instance): self.instances[instance['id']] = instance + self.add_filters_for_instance(instance) + self.iptables.apply() + def add_filters_for_instance(self, instance): chain_name = self._instance_chain_name(instance) self.iptables.ipv4['filter'].add_chain(chain_name) @@ -1257,18 +1260,17 @@ class IptablesFirewallDriver(FirewallDriver): for rule in ipv6_rules: self.iptables.ipv6['filter'].add_rule(chain_name, rule) + def unfilter_instance(self, instance): + self.remove_filters_for_instance(instance) self.iptables.apply() - def unfilter_instance(self, instance): + def remove_filters_for_instance(self, instance): chain_name = self._instance_chain_name(instance) self.iptables.ipv4['filter'].remove_chain(chain_name) if FLAGS.use_ipv6: self.iptables.ipv6['filter'].remove_chain(chain_name) - self.iptables.apply() - - def instance_rules(self, instance): ctxt = context.get_admin_context() @@ -1374,7 +1376,10 @@ class IptablesFirewallDriver(FirewallDriver): pass def refresh_security_group_rules(self, security_group): - self.apply_ruleset() + for instance in self.instances: + self.remove_filters_for_instance(instance) + self.add_filters_for_instance(instance) + self.iptables.apply() def _security_group_chain_name(self, security_group_id): return 'nova-sg-%s' % (security_group_id,) -- cgit From cbb0402efac4ededdda0ac2097ec087216e23931 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Mon, 21 Feb 2011 10:18:43 +0100 Subject: Also remove rules that jump to deleted chains. --- nova/virt/libvirt_conn.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 3faf01f4b..daf8f0ed7 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -44,9 +44,6 @@ import uuid from xml.dom import minidom -from eventlet import greenthread -from eventlet import event -from eventlet import semaphore from eventlet import tpool import IPy @@ -1246,7 +1243,7 @@ class IptablesFirewallDriver(FirewallDriver): if FLAGS.use_ipv6: self.iptables.ipv6['filter'].add_chain(chain_name) ipv6_address = self._ip_for_instance_v6(instance) - self.iptables.ipv4['filter'].add_rule('local', + self.iptables.ipv6['filter'].add_rule('local', '-d %s -j $%s' % (ipv6_address, chain_name)) @@ -1376,7 +1373,7 @@ class IptablesFirewallDriver(FirewallDriver): pass def refresh_security_group_rules(self, security_group): - for instance in self.instances: + for instance in self.instances.values(): self.remove_filters_for_instance(instance) self.add_filters_for_instance(instance) self.iptables.apply() -- cgit From 9eebe4317f86ae13ffeaca1622e9fc555bc28ebc Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Mon, 21 Feb 2011 10:42:59 +0100 Subject: Unfilter instance correctly on termination. --- nova/virt/libvirt_conn.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index daf8f0ed7..0c355e48e 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1219,9 +1219,11 @@ class IptablesFirewallDriver(FirewallDriver): """No-op. Everything is done in prepare_instance_filter""" pass - def remove_instance(self, instance): + def unfilter_instance(self, instance): if instance['id'] in self.instances: del self.instances[instance['id']] + self.remove_filters_for_instance(instance) + self.iptables.apply() else: LOG.info(_('Attempted to unfilter instance %s which is not ' 'filtered'), instance['id']) @@ -1257,10 +1259,6 @@ class IptablesFirewallDriver(FirewallDriver): for rule in ipv6_rules: self.iptables.ipv6['filter'].add_rule(chain_name, rule) - def unfilter_instance(self, instance): - self.remove_filters_for_instance(instance) - self.iptables.apply() - def remove_filters_for_instance(self, instance): chain_name = self._instance_chain_name(instance) -- cgit From e263a37f83ec5f8a1d81b0f4ec7a91464b2bc022 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Mon, 21 Feb 2011 11:02:19 +0000 Subject: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ NOVA-CORE DEVELOPERS SHOULD NOT REVIEW THIS MERGE PROPOSAL ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This is for Citrix OpenStack team only. We propose for merge into a cache of lp:nova to generate diffs for our internal peer review. --- nova/virt/xenapi/vmops.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 9bd671045..09f5a1c94 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -141,6 +141,7 @@ class VMOps(object): #this will return the appropriate network #TODO(salvatore-orlando): avoid unnecessary call to #find_network_with_bridge when VLAN manager is being used + network_ref = None try: network_ref = \ -- cgit From a57dffb5fdfbfac59b9ddbe7b33d6f03b7b748ba Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Mon, 21 Feb 2011 14:16:42 +0100 Subject: PEP-8 fixes --- nova/virt/libvirt_conn.py | 2 -- 1 file changed, 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0c355e48e..7f74e3505 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1303,11 +1303,9 @@ class IptablesFirewallDriver(FirewallDriver): cidrv6 = self._project_cidrv6_for_instance(instance) ipv6_rules += ['-s %s -j ACCEPT' % (cidrv6,)] - security_groups = db.security_group_get_by_instance(ctxt, instance['id']) - # then, security group chains and rules for security_group in security_groups: rules = db.security_group_rule_get_by_security_group(ctxt, -- cgit From 45f4b75491ef9f77b454792770609e0aa003a6e5 Mon Sep 17 00:00:00 2001 From: sateesh Date: Mon, 21 Feb 2011 19:42:20 +0530 Subject: * Removed nova/virt/guest-tools/guest_tool.bat & nova/virt/guest-tools/guest_tool.sh as guest_tool.py can be invoked directly during guest startup. * Removed 'nova/virt/guest-tools/' and the encompassed script 'guest_tool.py' is moved to 'etc/vmware_guest_tool.py' * Moved image vmwareapi_blockdiagram.jpg from 'nova/virt/' to 'doc/source/images/' so that it'll be picked up by document build scripts. * Moved vmwareapi_readme.rst from 'nova/virt/' to 'doc/source/' so that it'll be handled by document build scripts. * Added 'Introduction' section to 'vmwareapi_readme.rst' * Added vmwareapi module diagram to readme document. Added reference to 'images/vmwareapi_blockdiagram.jpg' in document 'vmwareapi_readme.rst' --- nova/virt/guest-tools/guest_tool.bat | 5 - nova/virt/guest-tools/guest_tool.py | 317 ----------------------------------- nova/virt/guest-tools/guest_tool.sh | 4 - 3 files changed, 326 deletions(-) delete mode 100644 nova/virt/guest-tools/guest_tool.bat delete mode 100644 nova/virt/guest-tools/guest_tool.py delete mode 100644 nova/virt/guest-tools/guest_tool.sh (limited to 'nova/virt') diff --git a/nova/virt/guest-tools/guest_tool.bat b/nova/virt/guest-tools/guest_tool.bat deleted file mode 100644 index f7445d05c..000000000 --- a/nova/virt/guest-tools/guest_tool.bat +++ /dev/null @@ -1,5 +0,0 @@ -@echo off - -set GuestToolsHome=%~dp0 -set PATH=%PATH%;%GuestToolsHome%\Python24 -"%GuestToolsHome%\Python24\python.exe" "%GuestToolsHome%\guest_tool.py" \ No newline at end of file diff --git a/nova/virt/guest-tools/guest_tool.py b/nova/virt/guest-tools/guest_tool.py deleted file mode 100644 index c605e47d2..000000000 --- a/nova/virt/guest-tools/guest_tool.py +++ /dev/null @@ -1,317 +0,0 @@ -# vim: tabstop=4 shiftwidth=4 softtabstop=4 - -# Copyright (c) 2011 Citrix Systems, Inc. -# Copyright 2011 OpenStack LLC. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -import os -import sys -import subprocess -import time -import array -import struct -import socket -import platform -import logging - -FORMAT = "%(asctime)s - %(levelname)s - %(message)s" -if sys.platform == 'win32': - LOG_DIR = os.path.join(os.environ.get('ALLUSERSPROFILE'), 'openstack') -elif sys.platform == 'linux2': - LOG_DIR = '/var/log/openstack' -else: - LOG_DIR = 'logs' -if not os.path.exists(LOG_DIR): - os.mkdir(LOG_DIR) -LOG_FILENAME = os.path.join(LOG_DIR, 'openstack-guest-tools.log') -logging.basicConfig(filename=LOG_FILENAME, format=FORMAT) - -if sys.hexversion < 0x3000000: - _byte = ord # 2.x chr to integer -else: - _byte = int # 3.x byte to integer - - -class ProcessExecutionError: - """ - Process Execution Error Class - """ - - def __init__(self, exit_code, stdout, stderr, cmd): - """ - The Intializer - """ - self.exit_code = exit_code - self.stdout = stdout - self.stderr = stderr - self.cmd = cmd - - def __str__(self): - """ - The informal string representation of the object - """ - return str(self.exit_code) - - -def _bytes2int(bytes): - """ - convert bytes to int. - """ - intgr = 0 - for byt in bytes: - intgr = (intgr << 8) + _byte(byt) - return intgr - - -def _parse_network_details(machine_id): - """ - Parse the machine.id field to get MAC, IP, Netmask and Gateway feilds - machine.id is of the form MAC;IP;Netmask;Gateway; - ; is the separator - """ - network_details = [] - if machine_id[1].strip() == 'No machine id': - pass - else: - network_info_list = machine_id[0].split(';') - assert len(network_info_list) % 4 == 0 - for i in xrange(0, len(network_info_list) / 4): - network_details.append((network_info_list[i].strip().lower(), - network_info_list[i + 1].strip(), - network_info_list[i + 2].strip(), - network_info_list[i + 3].strip())) - return network_details - - -def _get_windows_network_adapters(): - """ - Get the list of windows network adapters - """ - import win32com.client - wbem_locator = win32com.client.Dispatch('WbemScripting.SWbemLocator') - wbem_service = wbem_locator.ConnectServer('.', 'root\cimv2') - wbem_network_adapters = wbem_service.InstancesOf('Win32_NetworkAdapter') - network_adapters = [] - for wbem_network_adapter in wbem_network_adapters: - if wbem_network_adapter.NetConnectionStatus == 2 or \ - wbem_network_adapter.NetConnectionStatus == 7: - adapter_name = wbem_network_adapter.NetConnectionID - mac_address = wbem_network_adapter.MacAddress.lower() - wbem_network_adapter_config = \ - wbem_network_adapter.associators_( - 'Win32_NetworkAdapterSetting', - 'Win32_NetworkAdapterConfiguration')[0] - ip_address = '' - subnet_mask = '' - if wbem_network_adapter_config.IPEnabled: - ip_address = wbem_network_adapter_config.IPAddress[0] - subnet_mask = wbem_network_adapter_config.IPSubnet[0] - #wbem_network_adapter_config.DefaultIPGateway[0] - network_adapters.append({'name': adapter_name, - 'mac-address': mac_address, - 'ip-address': ip_address, - 'subnet-mask': subnet_mask}) - return network_adapters - - -def _get_linux_network_adapters(): - """ - Get the list of Linux network adapters - """ - import fcntl - max_bytes = 8096 - arch = platform.architecture()[0] - if arch == '32bit': - offset1 = 32 - offset2 = 32 - elif arch == '64bit': - offset1 = 16 - offset2 = 40 - else: - raise OSError("Unknown architecture: %s" % arch) - sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) - names = array.array('B', '\0' * max_bytes) - outbytes = struct.unpack('iL', fcntl.ioctl( - sock.fileno(), - 0x8912, - struct.pack('iL', max_bytes, names.buffer_info()[0])))[0] - adapter_names = \ - [names.tostring()[n_counter:n_counter + offset1].split('\0', 1)[0] - for n_counter in xrange(0, outbytes, offset2)] - network_adapters = [] - for adapter_name in adapter_names: - ip_address = socket.inet_ntoa(fcntl.ioctl( - sock.fileno(), - 0x8915, - struct.pack('256s', adapter_name))[20:24]) - subnet_mask = socket.inet_ntoa(fcntl.ioctl( - sock.fileno(), - 0x891b, - struct.pack('256s', adapter_name))[20:24]) - raw_mac_address = '%012x' % _bytes2int(fcntl.ioctl( - sock.fileno(), - 0x8927, - struct.pack('256s', adapter_name))[18:24]) - mac_address = ":".join([raw_mac_address[m_counter:m_counter + 2] - for m_counter in range(0, len(raw_mac_address), 2)]).lower() - network_adapters.append({'name': adapter_name, - 'mac-address': mac_address, - 'ip-address': ip_address, - 'subnet-mask': subnet_mask}) - return network_adapters - - -def _get_adapter_name_and_ip_address(network_adapters, mac_address): - """ - Get the adapter name based on the MAC address - """ - adapter_name = None - ip_address = None - for network_adapter in network_adapters: - if network_adapter['mac-address'] == mac_address.lower(): - adapter_name = network_adapter['name'] - ip_address = network_adapter['ip-address'] - break - return adapter_name, ip_address - - -def _get_win_adapter_name_and_ip_address(mac_address): - """ - Get the Windows network adapter name - """ - network_adapters = _get_windows_network_adapters() - return _get_adapter_name_and_ip_address(network_adapters, mac_address) - - -def _get_linux_adapter_name_and_ip_address(mac_address): - """ - Get the Linux adapter name - """ - network_adapters = _get_linux_network_adapters() - return _get_adapter_name_and_ip_address(network_adapters, mac_address) - - -def _execute(cmd_list, process_input=None, check_exit_code=True): - """ - Executes the command with the list of arguments specified - """ - cmd = ' '.join(cmd_list) - logging.debug('Executing command "%s"' % cmd) - env = os.environ.copy() - obj = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, - stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env) - result = None - if process_input != None: - result = obj.communicate(process_input) - else: - result = obj.communicate() - obj.stdin.close() - if obj.returncode: - logging.debug('Result was %s' % obj.returncode) - if check_exit_code and obj.returncode != 0: - (stdout, stderr) = result - raise ProcessExecutionError(exit_code=obj.returncode, - stdout=stdout, - stderr=stderr, - cmd=cmd) - time.sleep(0.1) - return result - - -def _windows_set_ipaddress(): - """ - Set IP address for the windows VM - """ - program_files = os.environ.get('PROGRAMFILES') - program_files_x86 = os.environ.get('PROGRAMFILES(X86)') - vmware_tools_bin = None - if os.path.exists(os.path.join(program_files, 'VMware', 'VMware Tools', - 'vmtoolsd.exe')): - vmware_tools_bin = os.path.join(program_files, 'VMware', - 'VMware Tools', 'vmtoolsd.exe') - elif os.path.exists(os.path.join(program_files, 'VMware', 'VMware Tools', - 'VMwareService.exe')): - vmware_tools_bin = os.path.join(program_files, 'VMware', - 'VMware Tools', 'VMwareService.exe') - elif program_files_x86 and os.path.exists(os.path.join(program_files_x86, - 'VMware', 'VMware Tools', - 'VMwareService.exe')): - vmware_tools_bin = os.path.join(program_files_x86, 'VMware', - 'VMware Tools', 'VMwareService.exe') - if vmware_tools_bin: - cmd = ['"' + vmware_tools_bin + '"', '--cmd', 'machine.id.get'] - for network_detail in _parse_network_details(_execute(cmd, - check_exit_code=False)): - mac_address, ip_address, subnet_mask, gateway = network_detail - adapter_name, current_ip_address = \ - _get_win_adapter_name_and_ip_address(mac_address) - if adapter_name and not ip_address == current_ip_address: - cmd = ['netsh', 'interface', 'ip', 'set', 'address', - 'name="%s"' % adapter_name, 'source=static', ip_address, - subnet_mask, gateway, '1'] - _execute(cmd) - else: - logging.warn('VMware Tools is not installed') - - -def _linux_set_ipaddress(): - """ - Set IP address for the Linux VM - """ - vmware_tools_bin = None - if os.path.exists('/usr/sbin/vmtoolsd'): - vmware_tools_bin = '/usr/sbin/vmtoolsd' - elif os.path.exists('/usr/bin/vmtoolsd'): - vmware_tools_bin = '/usr/bin/vmtoolsd' - elif os.path.exists('/usr/sbin/vmware-guestd'): - vmware_tools_bin = '/usr/sbin/vmware-guestd' - elif os.path.exists('/usr/bin/vmware-guestd'): - vmware_tools_bin = '/usr/bin/vmware-guestd' - if vmware_tools_bin: - cmd = [vmware_tools_bin, '--cmd', 'machine.id.get'] - for network_detail in _parse_network_details(_execute(cmd, - check_exit_code=False)): - mac_address, ip_address, subnet_mask, gateway = network_detail - adapter_name, current_ip_address = \ - _get_linux_adapter_name_and_ip_address(mac_address) - if adapter_name and not ip_address == current_ip_address: - interface_file_name = \ - '/etc/sysconfig/network-scripts/ifcfg-%s' % adapter_name - #Remove file - os.remove(interface_file_name) - #Touch file - _execute(['touch', interface_file_name]) - interface_file = open(interface_file_name, 'w') - interface_file.write('\nDEVICE=%s' % adapter_name) - interface_file.write('\nUSERCTL=yes') - interface_file.write('\nONBOOT=yes') - interface_file.write('\nBOOTPROTO=static') - interface_file.write('\nBROADCAST=') - interface_file.write('\nNETWORK=') - interface_file.write('\nNETMASK=%s' % subnet_mask) - interface_file.write('\nIPADDR=%s' % ip_address) - interface_file.write('\nMACADDR=%s' % mac_address) - interface_file.close() - _execute(['/sbin/service', 'network' 'restart']) - else: - logging.warn('VMware Tools is not installed') - -if __name__ == '__main__': - pltfrm = sys.platform - if pltfrm == 'win32': - _windows_set_ipaddress() - elif pltfrm == 'linux2': - _linux_set_ipaddress() - else: - raise NotImplementedError('Platform not implemented:"%s"' % pltfrm) diff --git a/nova/virt/guest-tools/guest_tool.sh b/nova/virt/guest-tools/guest_tool.sh deleted file mode 100644 index 1bfbc7804..000000000 --- a/nova/virt/guest-tools/guest_tool.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/sh -##!/usr/bin/bash - -python guest_tool.py \ No newline at end of file -- cgit From eebb9bb14edb6fd1d218b3aa18142ee739ddd715 Mon Sep 17 00:00:00 2001 From: Christian Berendt Date: Mon, 21 Feb 2011 16:16:21 +0100 Subject: introducing a new flag timeout_nbd for manually setting the time in seconds for waiting for an upcoming NBD device --- nova/virt/disk.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index c5565abfa..cb639a102 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -38,6 +38,8 @@ flags.DEFINE_integer('minimum_root_size', 1024 * 1024 * 1024 * 10, 'minimum size in bytes of root partition') flags.DEFINE_integer('block_size', 1024 * 1024 * 256, 'block_size to use for dd') +flags.DEFINE_integer('timeout_nbd', 10, + 'time to wait for a NBD device coming up') def extend(image, size): @@ -117,7 +119,7 @@ def _link_device(image, nbd): utils.execute('sudo qemu-nbd -c %s %s' % (device, image)) # NOTE(vish): this forks into another process, so give it a chance # to set up before continuuing - for i in xrange(10): + for i in xrange(FLAGS.timeout_nbd): if os.path.exists("/sys/block/%s/pid" % os.path.basename(device)): return device time.sleep(1) -- cgit From d5b81fa45fb43e1f90c572b7291280735aef2af8 Mon Sep 17 00:00:00 2001 From: sateesh Date: Mon, 21 Feb 2011 21:21:45 +0530 Subject: * Removed VimService_services.py & VimService_services_types.py to reduce the diffs to normal. These 2 files are auto-generated files containing stubs for VI SDK API end points. The stub files are generated using ZSI SOAP stub generator module ZSI.commands.wsdl2py over Vimservice.wsdl distributed as part of VMware Virtual Infrastructure SDK package. To not include them in the repository we have few options to choose from, 1) Generate the stub files in build time and make them available as packages for distribution. 2) Generate the stub files in installation/configuration time if ESX/ESXi server is detected as compute provider. Further to this, we can try to reduce the size of stub files by attempting to create stubs only for the API end points required by the module vmwareapi. * Removed vmwareapi_blockdiagram.jpg as it was moved to 'doc/source/images' in revision 448. * Removed vmwareapi_readme.rst as it was moved to 'doc/source' in revision 448. --- nova/virt/vmwareapi/VimService_services.py | 8369 --- nova/virt/vmwareapi/VimService_services_types.py | 72377 --------------------- nova/virt/vmwareapi_blockdiagram.jpg | Bin 75363 -> 0 bytes nova/virt/vmwareapi_readme.rst | 72 - 4 files changed, 80818 deletions(-) delete mode 100644 nova/virt/vmwareapi/VimService_services.py delete mode 100644 nova/virt/vmwareapi/VimService_services_types.py delete mode 100644 nova/virt/vmwareapi_blockdiagram.jpg delete mode 100644 nova/virt/vmwareapi_readme.rst (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/VimService_services.py b/nova/virt/vmwareapi/VimService_services.py deleted file mode 100644 index 28767ffca..000000000 --- a/nova/virt/vmwareapi/VimService_services.py +++ /dev/null @@ -1,8369 +0,0 @@ -################################################## -# VimService_services.py -# generated by ZSI.generate.wsdl2python -################################################## - - -from VimService_services_types import * -import urlparse, types -from ZSI.TCcompound import ComplexType, Struct -from ZSI import client -import ZSI -from ZSI.generate.pyclass import pyclass_type - -# Locator -class VimServiceLocator: - VimPortType_address = "https://localhost/sdk/vimService" - def getVimPortTypeAddress(self): - return VimServiceLocator.VimPortType_address - def getVimPortType(self, url=None, **kw): - return VimBindingSOAP(url or VimServiceLocator.VimPortType_address, **kw) - -# Methods -class VimBindingSOAP: - def __init__(self, url, **kw): - kw.setdefault("readerclass", None) - kw.setdefault("writerclass", None) - # no resource properties - self.binding = client.Binding(url=url, **kw) - # no ws-addressing - - # op: DestroyPropertyFilter - def DestroyPropertyFilter(self, request): - if isinstance(request, DestroyPropertyFilterRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyPropertyFilterResponseMsg.typecode) - return response - - # op: CreateFilter - def CreateFilter(self, request): - if isinstance(request, CreateFilterRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateFilterResponseMsg.typecode) - return response - - # op: RetrieveProperties - def RetrieveProperties(self, request): - if isinstance(request, RetrievePropertiesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrievePropertiesResponseMsg.typecode) - return response - - # op: CheckForUpdates - def CheckForUpdates(self, request): - if isinstance(request, CheckForUpdatesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckForUpdatesResponseMsg.typecode) - return response - - # op: WaitForUpdates - def WaitForUpdates(self, request): - if isinstance(request, WaitForUpdatesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(WaitForUpdatesResponseMsg.typecode) - return response - - # op: CancelWaitForUpdates - def CancelWaitForUpdates(self, request): - if isinstance(request, CancelWaitForUpdatesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CancelWaitForUpdatesResponseMsg.typecode) - return response - - # op: AddAuthorizationRole - def AddAuthorizationRole(self, request): - if isinstance(request, AddAuthorizationRoleRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddAuthorizationRoleResponseMsg.typecode) - return response - - # op: RemoveAuthorizationRole - def RemoveAuthorizationRole(self, request): - if isinstance(request, RemoveAuthorizationRoleRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveAuthorizationRoleResponseMsg.typecode) - return response - - # op: UpdateAuthorizationRole - def UpdateAuthorizationRole(self, request): - if isinstance(request, UpdateAuthorizationRoleRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateAuthorizationRoleResponseMsg.typecode) - return response - - # op: MergePermissions - def MergePermissions(self, request): - if isinstance(request, MergePermissionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MergePermissionsResponseMsg.typecode) - return response - - # op: RetrieveRolePermissions - def RetrieveRolePermissions(self, request): - if isinstance(request, RetrieveRolePermissionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveRolePermissionsResponseMsg.typecode) - return response - - # op: RetrieveEntityPermissions - def RetrieveEntityPermissions(self, request): - if isinstance(request, RetrieveEntityPermissionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveEntityPermissionsResponseMsg.typecode) - return response - - # op: RetrieveAllPermissions - def RetrieveAllPermissions(self, request): - if isinstance(request, RetrieveAllPermissionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveAllPermissionsResponseMsg.typecode) - return response - - # op: SetEntityPermissions - def SetEntityPermissions(self, request): - if isinstance(request, SetEntityPermissionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetEntityPermissionsResponseMsg.typecode) - return response - - # op: ResetEntityPermissions - def ResetEntityPermissions(self, request): - if isinstance(request, ResetEntityPermissionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetEntityPermissionsResponseMsg.typecode) - return response - - # op: RemoveEntityPermission - def RemoveEntityPermission(self, request): - if isinstance(request, RemoveEntityPermissionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveEntityPermissionResponseMsg.typecode) - return response - - # op: ReconfigureCluster - def ReconfigureCluster(self, request): - if isinstance(request, ReconfigureClusterRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureClusterResponseMsg.typecode) - return response - - # op: ReconfigureCluster_Task - def ReconfigureCluster_Task(self, request): - if isinstance(request, ReconfigureCluster_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureCluster_TaskResponseMsg.typecode) - return response - - # op: ApplyRecommendation - def ApplyRecommendation(self, request): - if isinstance(request, ApplyRecommendationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ApplyRecommendationResponseMsg.typecode) - return response - - # op: RecommendHostsForVm - def RecommendHostsForVm(self, request): - if isinstance(request, RecommendHostsForVmRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RecommendHostsForVmResponseMsg.typecode) - return response - - # op: AddHost - def AddHost(self, request): - if isinstance(request, AddHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddHostResponseMsg.typecode) - return response - - # op: AddHost_Task - def AddHost_Task(self, request): - if isinstance(request, AddHost_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddHost_TaskResponseMsg.typecode) - return response - - # op: MoveInto - def MoveInto(self, request): - if isinstance(request, MoveIntoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveIntoResponseMsg.typecode) - return response - - # op: MoveInto_Task - def MoveInto_Task(self, request): - if isinstance(request, MoveInto_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveInto_TaskResponseMsg.typecode) - return response - - # op: MoveHostInto - def MoveHostInto(self, request): - if isinstance(request, MoveHostIntoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveHostIntoResponseMsg.typecode) - return response - - # op: MoveHostInto_Task - def MoveHostInto_Task(self, request): - if isinstance(request, MoveHostInto_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveHostInto_TaskResponseMsg.typecode) - return response - - # op: RefreshRecommendation - def RefreshRecommendation(self, request): - if isinstance(request, RefreshRecommendationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshRecommendationResponseMsg.typecode) - return response - - # op: RetrieveDasAdvancedRuntimeInfo - def RetrieveDasAdvancedRuntimeInfo(self, request): - if isinstance(request, RetrieveDasAdvancedRuntimeInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveDasAdvancedRuntimeInfoResponseMsg.typecode) - return response - - # op: ReconfigureComputeResource - def ReconfigureComputeResource(self, request): - if isinstance(request, ReconfigureComputeResourceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureComputeResourceResponseMsg.typecode) - return response - - # op: ReconfigureComputeResource_Task - def ReconfigureComputeResource_Task(self, request): - if isinstance(request, ReconfigureComputeResource_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureComputeResource_TaskResponseMsg.typecode) - return response - - # op: AddCustomFieldDef - def AddCustomFieldDef(self, request): - if isinstance(request, AddCustomFieldDefRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddCustomFieldDefResponseMsg.typecode) - return response - - # op: RemoveCustomFieldDef - def RemoveCustomFieldDef(self, request): - if isinstance(request, RemoveCustomFieldDefRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveCustomFieldDefResponseMsg.typecode) - return response - - # op: RenameCustomFieldDef - def RenameCustomFieldDef(self, request): - if isinstance(request, RenameCustomFieldDefRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RenameCustomFieldDefResponseMsg.typecode) - return response - - # op: SetField - def SetField(self, request): - if isinstance(request, SetFieldRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetFieldResponseMsg.typecode) - return response - - # op: DoesCustomizationSpecExist - def DoesCustomizationSpecExist(self, request): - if isinstance(request, DoesCustomizationSpecExistRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DoesCustomizationSpecExistResponseMsg.typecode) - return response - - # op: GetCustomizationSpec - def GetCustomizationSpec(self, request): - if isinstance(request, GetCustomizationSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GetCustomizationSpecResponseMsg.typecode) - return response - - # op: CreateCustomizationSpec - def CreateCustomizationSpec(self, request): - if isinstance(request, CreateCustomizationSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateCustomizationSpecResponseMsg.typecode) - return response - - # op: OverwriteCustomizationSpec - def OverwriteCustomizationSpec(self, request): - if isinstance(request, OverwriteCustomizationSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(OverwriteCustomizationSpecResponseMsg.typecode) - return response - - # op: DeleteCustomizationSpec - def DeleteCustomizationSpec(self, request): - if isinstance(request, DeleteCustomizationSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DeleteCustomizationSpecResponseMsg.typecode) - return response - - # op: DuplicateCustomizationSpec - def DuplicateCustomizationSpec(self, request): - if isinstance(request, DuplicateCustomizationSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DuplicateCustomizationSpecResponseMsg.typecode) - return response - - # op: RenameCustomizationSpec - def RenameCustomizationSpec(self, request): - if isinstance(request, RenameCustomizationSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RenameCustomizationSpecResponseMsg.typecode) - return response - - # op: CustomizationSpecItemToXml - def CustomizationSpecItemToXml(self, request): - if isinstance(request, CustomizationSpecItemToXmlRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CustomizationSpecItemToXmlResponseMsg.typecode) - return response - - # op: XmlToCustomizationSpecItem - def XmlToCustomizationSpecItem(self, request): - if isinstance(request, XmlToCustomizationSpecItemRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(XmlToCustomizationSpecItemResponseMsg.typecode) - return response - - # op: CheckCustomizationResources - def CheckCustomizationResources(self, request): - if isinstance(request, CheckCustomizationResourcesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckCustomizationResourcesResponseMsg.typecode) - return response - - # op: QueryConnectionInfo - def QueryConnectionInfo(self, request): - if isinstance(request, QueryConnectionInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryConnectionInfoResponseMsg.typecode) - return response - - # op: PowerOnMultiVM - def PowerOnMultiVM(self, request): - if isinstance(request, PowerOnMultiVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOnMultiVMResponseMsg.typecode) - return response - - # op: PowerOnMultiVM_Task - def PowerOnMultiVM_Task(self, request): - if isinstance(request, PowerOnMultiVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOnMultiVM_TaskResponseMsg.typecode) - return response - - # op: RefreshDatastore - def RefreshDatastore(self, request): - if isinstance(request, RefreshDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshDatastoreResponseMsg.typecode) - return response - - # op: RefreshDatastoreStorageInfo - def RefreshDatastoreStorageInfo(self, request): - if isinstance(request, RefreshDatastoreStorageInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshDatastoreStorageInfoResponseMsg.typecode) - return response - - # op: RenameDatastore - def RenameDatastore(self, request): - if isinstance(request, RenameDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RenameDatastoreResponseMsg.typecode) - return response - - # op: DestroyDatastore - def DestroyDatastore(self, request): - if isinstance(request, DestroyDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyDatastoreResponseMsg.typecode) - return response - - # op: QueryDescriptions - def QueryDescriptions(self, request): - if isinstance(request, QueryDescriptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryDescriptionsResponseMsg.typecode) - return response - - # op: BrowseDiagnosticLog - def BrowseDiagnosticLog(self, request): - if isinstance(request, BrowseDiagnosticLogRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(BrowseDiagnosticLogResponseMsg.typecode) - return response - - # op: GenerateLogBundles - def GenerateLogBundles(self, request): - if isinstance(request, GenerateLogBundlesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GenerateLogBundlesResponseMsg.typecode) - return response - - # op: GenerateLogBundles_Task - def GenerateLogBundles_Task(self, request): - if isinstance(request, GenerateLogBundles_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GenerateLogBundles_TaskResponseMsg.typecode) - return response - - # op: DVSFetchKeyOfPorts - def DVSFetchKeyOfPorts(self, request): - if isinstance(request, DVSFetchKeyOfPortsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSFetchKeyOfPortsResponseMsg.typecode) - return response - - # op: DVSFetchPorts - def DVSFetchPorts(self, request): - if isinstance(request, DVSFetchPortsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSFetchPortsResponseMsg.typecode) - return response - - # op: DVSQueryUsedVlanId - def DVSQueryUsedVlanId(self, request): - if isinstance(request, DVSQueryUsedVlanIdRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSQueryUsedVlanIdResponseMsg.typecode) - return response - - # op: DVSReconfigure - def DVSReconfigure(self, request): - if isinstance(request, DVSReconfigureRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSReconfigureResponseMsg.typecode) - return response - - # op: DVSReconfigure_Task - def DVSReconfigure_Task(self, request): - if isinstance(request, DVSReconfigure_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSReconfigure_TaskResponseMsg.typecode) - return response - - # op: DVSPerformProductSpecOperation - def DVSPerformProductSpecOperation(self, request): - if isinstance(request, DVSPerformProductSpecOperationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSPerformProductSpecOperationResponseMsg.typecode) - return response - - # op: DVSPerformProductSpecOperation_Task - def DVSPerformProductSpecOperation_Task(self, request): - if isinstance(request, DVSPerformProductSpecOperation_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSPerformProductSpecOperation_TaskResponseMsg.typecode) - return response - - # op: DVSMerge - def DVSMerge(self, request): - if isinstance(request, DVSMergeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSMergeResponseMsg.typecode) - return response - - # op: DVSMerge_Task - def DVSMerge_Task(self, request): - if isinstance(request, DVSMerge_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSMerge_TaskResponseMsg.typecode) - return response - - # op: DVSAddPortgroups - def DVSAddPortgroups(self, request): - if isinstance(request, DVSAddPortgroupsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSAddPortgroupsResponseMsg.typecode) - return response - - # op: DVSMovePort - def DVSMovePort(self, request): - if isinstance(request, DVSMovePortRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSMovePortResponseMsg.typecode) - return response - - # op: DVSUpdateCapability - def DVSUpdateCapability(self, request): - if isinstance(request, DVSUpdateCapabilityRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSUpdateCapabilityResponseMsg.typecode) - return response - - # op: ReconfigurePort - def ReconfigurePort(self, request): - if isinstance(request, ReconfigurePortRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigurePortResponseMsg.typecode) - return response - - # op: DVSRefreshPortState - def DVSRefreshPortState(self, request): - if isinstance(request, DVSRefreshPortStateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSRefreshPortStateResponseMsg.typecode) - return response - - # op: DVSRectifyHost - def DVSRectifyHost(self, request): - if isinstance(request, DVSRectifyHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSRectifyHostResponseMsg.typecode) - return response - - # op: QueryConfigOptionDescriptor - def QueryConfigOptionDescriptor(self, request): - if isinstance(request, QueryConfigOptionDescriptorRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryConfigOptionDescriptorResponseMsg.typecode) - return response - - # op: QueryConfigOption - def QueryConfigOption(self, request): - if isinstance(request, QueryConfigOptionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryConfigOptionResponseMsg.typecode) - return response - - # op: QueryConfigTarget - def QueryConfigTarget(self, request): - if isinstance(request, QueryConfigTargetRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryConfigTargetResponseMsg.typecode) - return response - - # op: QueryTargetCapabilities - def QueryTargetCapabilities(self, request): - if isinstance(request, QueryTargetCapabilitiesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryTargetCapabilitiesResponseMsg.typecode) - return response - - # op: setCustomValue - def setCustomValue(self, request): - if isinstance(request, setCustomValueRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(setCustomValueResponseMsg.typecode) - return response - - # op: UnregisterExtension - def UnregisterExtension(self, request): - if isinstance(request, UnregisterExtensionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UnregisterExtensionResponseMsg.typecode) - return response - - # op: FindExtension - def FindExtension(self, request): - if isinstance(request, FindExtensionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindExtensionResponseMsg.typecode) - return response - - # op: RegisterExtension - def RegisterExtension(self, request): - if isinstance(request, RegisterExtensionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RegisterExtensionResponseMsg.typecode) - return response - - # op: UpdateExtension - def UpdateExtension(self, request): - if isinstance(request, UpdateExtensionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateExtensionResponseMsg.typecode) - return response - - # op: GetPublicKey - def GetPublicKey(self, request): - if isinstance(request, GetPublicKeyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GetPublicKeyResponseMsg.typecode) - return response - - # op: SetPublicKey - def SetPublicKey(self, request): - if isinstance(request, SetPublicKeyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetPublicKeyResponseMsg.typecode) - return response - - # op: MoveDatastoreFile - def MoveDatastoreFile(self, request): - if isinstance(request, MoveDatastoreFileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveDatastoreFileResponseMsg.typecode) - return response - - # op: MoveDatastoreFile_Task - def MoveDatastoreFile_Task(self, request): - if isinstance(request, MoveDatastoreFile_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveDatastoreFile_TaskResponseMsg.typecode) - return response - - # op: CopyDatastoreFile - def CopyDatastoreFile(self, request): - if isinstance(request, CopyDatastoreFileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CopyDatastoreFileResponseMsg.typecode) - return response - - # op: CopyDatastoreFile_Task - def CopyDatastoreFile_Task(self, request): - if isinstance(request, CopyDatastoreFile_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CopyDatastoreFile_TaskResponseMsg.typecode) - return response - - # op: DeleteDatastoreFile - def DeleteDatastoreFile(self, request): - if isinstance(request, DeleteDatastoreFileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DeleteDatastoreFileResponseMsg.typecode) - return response - - # op: DeleteDatastoreFile_Task - def DeleteDatastoreFile_Task(self, request): - if isinstance(request, DeleteDatastoreFile_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DeleteDatastoreFile_TaskResponseMsg.typecode) - return response - - # op: MakeDirectory - def MakeDirectory(self, request): - if isinstance(request, MakeDirectoryRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MakeDirectoryResponseMsg.typecode) - return response - - # op: ChangeOwner - def ChangeOwner(self, request): - if isinstance(request, ChangeOwnerRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ChangeOwnerResponseMsg.typecode) - return response - - # op: CreateFolder - def CreateFolder(self, request): - if isinstance(request, CreateFolderRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateFolderResponseMsg.typecode) - return response - - # op: MoveIntoFolder - def MoveIntoFolder(self, request): - if isinstance(request, MoveIntoFolderRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveIntoFolderResponseMsg.typecode) - return response - - # op: MoveIntoFolder_Task - def MoveIntoFolder_Task(self, request): - if isinstance(request, MoveIntoFolder_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveIntoFolder_TaskResponseMsg.typecode) - return response - - # op: CreateVM - def CreateVM(self, request): - if isinstance(request, CreateVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateVMResponseMsg.typecode) - return response - - # op: CreateVM_Task - def CreateVM_Task(self, request): - if isinstance(request, CreateVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateVM_TaskResponseMsg.typecode) - return response - - # op: RegisterVM - def RegisterVM(self, request): - if isinstance(request, RegisterVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RegisterVMResponseMsg.typecode) - return response - - # op: RegisterVM_Task - def RegisterVM_Task(self, request): - if isinstance(request, RegisterVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RegisterVM_TaskResponseMsg.typecode) - return response - - # op: CreateCluster - def CreateCluster(self, request): - if isinstance(request, CreateClusterRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateClusterResponseMsg.typecode) - return response - - # op: CreateClusterEx - def CreateClusterEx(self, request): - if isinstance(request, CreateClusterExRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateClusterExResponseMsg.typecode) - return response - - # op: AddStandaloneHost - def AddStandaloneHost(self, request): - if isinstance(request, AddStandaloneHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddStandaloneHostResponseMsg.typecode) - return response - - # op: AddStandaloneHost_Task - def AddStandaloneHost_Task(self, request): - if isinstance(request, AddStandaloneHost_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddStandaloneHost_TaskResponseMsg.typecode) - return response - - # op: CreateDatacenter - def CreateDatacenter(self, request): - if isinstance(request, CreateDatacenterRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateDatacenterResponseMsg.typecode) - return response - - # op: UnregisterAndDestroy - def UnregisterAndDestroy(self, request): - if isinstance(request, UnregisterAndDestroyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UnregisterAndDestroyResponseMsg.typecode) - return response - - # op: UnregisterAndDestroy_Task - def UnregisterAndDestroy_Task(self, request): - if isinstance(request, UnregisterAndDestroy_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UnregisterAndDestroy_TaskResponseMsg.typecode) - return response - - # op: FolderCreateDVS - def FolderCreateDVS(self, request): - if isinstance(request, FolderCreateDVSRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FolderCreateDVSResponseMsg.typecode) - return response - - # op: SetCollectorPageSize - def SetCollectorPageSize(self, request): - if isinstance(request, SetCollectorPageSizeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetCollectorPageSizeResponseMsg.typecode) - return response - - # op: RewindCollector - def RewindCollector(self, request): - if isinstance(request, RewindCollectorRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RewindCollectorResponseMsg.typecode) - return response - - # op: ResetCollector - def ResetCollector(self, request): - if isinstance(request, ResetCollectorRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetCollectorResponseMsg.typecode) - return response - - # op: DestroyCollector - def DestroyCollector(self, request): - if isinstance(request, DestroyCollectorRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyCollectorResponseMsg.typecode) - return response - - # op: QueryHostConnectionInfo - def QueryHostConnectionInfo(self, request): - if isinstance(request, QueryHostConnectionInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryHostConnectionInfoResponseMsg.typecode) - return response - - # op: UpdateSystemResources - def UpdateSystemResources(self, request): - if isinstance(request, UpdateSystemResourcesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateSystemResourcesResponseMsg.typecode) - return response - - # op: ReconnectHost - def ReconnectHost(self, request): - if isinstance(request, ReconnectHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconnectHostResponseMsg.typecode) - return response - - # op: ReconnectHost_Task - def ReconnectHost_Task(self, request): - if isinstance(request, ReconnectHost_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconnectHost_TaskResponseMsg.typecode) - return response - - # op: DisconnectHost - def DisconnectHost(self, request): - if isinstance(request, DisconnectHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisconnectHostResponseMsg.typecode) - return response - - # op: DisconnectHost_Task - def DisconnectHost_Task(self, request): - if isinstance(request, DisconnectHost_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisconnectHost_TaskResponseMsg.typecode) - return response - - # op: EnterMaintenanceMode - def EnterMaintenanceMode(self, request): - if isinstance(request, EnterMaintenanceModeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnterMaintenanceModeResponseMsg.typecode) - return response - - # op: EnterMaintenanceMode_Task - def EnterMaintenanceMode_Task(self, request): - if isinstance(request, EnterMaintenanceMode_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnterMaintenanceMode_TaskResponseMsg.typecode) - return response - - # op: ExitMaintenanceMode - def ExitMaintenanceMode(self, request): - if isinstance(request, ExitMaintenanceModeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExitMaintenanceModeResponseMsg.typecode) - return response - - # op: ExitMaintenanceMode_Task - def ExitMaintenanceMode_Task(self, request): - if isinstance(request, ExitMaintenanceMode_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExitMaintenanceMode_TaskResponseMsg.typecode) - return response - - # op: RebootHost - def RebootHost(self, request): - if isinstance(request, RebootHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RebootHostResponseMsg.typecode) - return response - - # op: RebootHost_Task - def RebootHost_Task(self, request): - if isinstance(request, RebootHost_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RebootHost_TaskResponseMsg.typecode) - return response - - # op: ShutdownHost - def ShutdownHost(self, request): - if isinstance(request, ShutdownHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ShutdownHostResponseMsg.typecode) - return response - - # op: ShutdownHost_Task - def ShutdownHost_Task(self, request): - if isinstance(request, ShutdownHost_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ShutdownHost_TaskResponseMsg.typecode) - return response - - # op: PowerDownHostToStandBy - def PowerDownHostToStandBy(self, request): - if isinstance(request, PowerDownHostToStandByRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerDownHostToStandByResponseMsg.typecode) - return response - - # op: PowerDownHostToStandBy_Task - def PowerDownHostToStandBy_Task(self, request): - if isinstance(request, PowerDownHostToStandBy_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerDownHostToStandBy_TaskResponseMsg.typecode) - return response - - # op: PowerUpHostFromStandBy - def PowerUpHostFromStandBy(self, request): - if isinstance(request, PowerUpHostFromStandByRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerUpHostFromStandByResponseMsg.typecode) - return response - - # op: PowerUpHostFromStandBy_Task - def PowerUpHostFromStandBy_Task(self, request): - if isinstance(request, PowerUpHostFromStandBy_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerUpHostFromStandBy_TaskResponseMsg.typecode) - return response - - # op: QueryMemoryOverhead - def QueryMemoryOverhead(self, request): - if isinstance(request, QueryMemoryOverheadRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryMemoryOverheadResponseMsg.typecode) - return response - - # op: QueryMemoryOverheadEx - def QueryMemoryOverheadEx(self, request): - if isinstance(request, QueryMemoryOverheadExRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryMemoryOverheadExResponseMsg.typecode) - return response - - # op: ReconfigureHostForDAS - def ReconfigureHostForDAS(self, request): - if isinstance(request, ReconfigureHostForDASRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureHostForDASResponseMsg.typecode) - return response - - # op: ReconfigureHostForDAS_Task - def ReconfigureHostForDAS_Task(self, request): - if isinstance(request, ReconfigureHostForDAS_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureHostForDAS_TaskResponseMsg.typecode) - return response - - # op: UpdateFlags - def UpdateFlags(self, request): - if isinstance(request, UpdateFlagsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateFlagsResponseMsg.typecode) - return response - - # op: AcquireCimServicesTicket - def AcquireCimServicesTicket(self, request): - if isinstance(request, AcquireCimServicesTicketRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AcquireCimServicesTicketResponseMsg.typecode) - return response - - # op: UpdateIpmi - def UpdateIpmi(self, request): - if isinstance(request, UpdateIpmiRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateIpmiResponseMsg.typecode) - return response - - # op: HttpNfcLeaseComplete - def HttpNfcLeaseComplete(self, request): - if isinstance(request, HttpNfcLeaseCompleteRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HttpNfcLeaseCompleteResponseMsg.typecode) - return response - - # op: HttpNfcLeaseAbort - def HttpNfcLeaseAbort(self, request): - if isinstance(request, HttpNfcLeaseAbortRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HttpNfcLeaseAbortResponseMsg.typecode) - return response - - # op: HttpNfcLeaseProgress - def HttpNfcLeaseProgress(self, request): - if isinstance(request, HttpNfcLeaseProgressRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HttpNfcLeaseProgressResponseMsg.typecode) - return response - - # op: QueryIpPools - def QueryIpPools(self, request): - if isinstance(request, QueryIpPoolsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryIpPoolsResponseMsg.typecode) - return response - - # op: CreateIpPool - def CreateIpPool(self, request): - if isinstance(request, CreateIpPoolRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateIpPoolResponseMsg.typecode) - return response - - # op: UpdateIpPool - def UpdateIpPool(self, request): - if isinstance(request, UpdateIpPoolRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateIpPoolResponseMsg.typecode) - return response - - # op: DestroyIpPool - def DestroyIpPool(self, request): - if isinstance(request, DestroyIpPoolRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyIpPoolResponseMsg.typecode) - return response - - # op: AssociateIpPool - def AssociateIpPool(self, request): - if isinstance(request, AssociateIpPoolRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AssociateIpPoolResponseMsg.typecode) - return response - - # op: UpdateAssignedLicense - def UpdateAssignedLicense(self, request): - if isinstance(request, UpdateAssignedLicenseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateAssignedLicenseResponseMsg.typecode) - return response - - # op: RemoveAssignedLicense - def RemoveAssignedLicense(self, request): - if isinstance(request, RemoveAssignedLicenseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveAssignedLicenseResponseMsg.typecode) - return response - - # op: QueryAssignedLicenses - def QueryAssignedLicenses(self, request): - if isinstance(request, QueryAssignedLicensesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryAssignedLicensesResponseMsg.typecode) - return response - - # op: IsFeatureAvailable - def IsFeatureAvailable(self, request): - if isinstance(request, IsFeatureAvailableRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(IsFeatureAvailableResponseMsg.typecode) - return response - - # op: SetFeatureInUse - def SetFeatureInUse(self, request): - if isinstance(request, SetFeatureInUseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetFeatureInUseResponseMsg.typecode) - return response - - # op: ResetFeatureInUse - def ResetFeatureInUse(self, request): - if isinstance(request, ResetFeatureInUseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetFeatureInUseResponseMsg.typecode) - return response - - # op: QuerySupportedFeatures - def QuerySupportedFeatures(self, request): - if isinstance(request, QuerySupportedFeaturesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QuerySupportedFeaturesResponseMsg.typecode) - return response - - # op: QueryLicenseSourceAvailability - def QueryLicenseSourceAvailability(self, request): - if isinstance(request, QueryLicenseSourceAvailabilityRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryLicenseSourceAvailabilityResponseMsg.typecode) - return response - - # op: QueryLicenseUsage - def QueryLicenseUsage(self, request): - if isinstance(request, QueryLicenseUsageRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryLicenseUsageResponseMsg.typecode) - return response - - # op: SetLicenseEdition - def SetLicenseEdition(self, request): - if isinstance(request, SetLicenseEditionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetLicenseEditionResponseMsg.typecode) - return response - - # op: CheckLicenseFeature - def CheckLicenseFeature(self, request): - if isinstance(request, CheckLicenseFeatureRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckLicenseFeatureResponseMsg.typecode) - return response - - # op: EnableFeature - def EnableFeature(self, request): - if isinstance(request, EnableFeatureRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnableFeatureResponseMsg.typecode) - return response - - # op: DisableFeature - def DisableFeature(self, request): - if isinstance(request, DisableFeatureRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisableFeatureResponseMsg.typecode) - return response - - # op: ConfigureLicenseSource - def ConfigureLicenseSource(self, request): - if isinstance(request, ConfigureLicenseSourceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ConfigureLicenseSourceResponseMsg.typecode) - return response - - # op: UpdateLicense - def UpdateLicense(self, request): - if isinstance(request, UpdateLicenseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateLicenseResponseMsg.typecode) - return response - - # op: AddLicense - def AddLicense(self, request): - if isinstance(request, AddLicenseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddLicenseResponseMsg.typecode) - return response - - # op: RemoveLicense - def RemoveLicense(self, request): - if isinstance(request, RemoveLicenseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveLicenseResponseMsg.typecode) - return response - - # op: DecodeLicense - def DecodeLicense(self, request): - if isinstance(request, DecodeLicenseRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DecodeLicenseResponseMsg.typecode) - return response - - # op: UpdateLicenseLabel - def UpdateLicenseLabel(self, request): - if isinstance(request, UpdateLicenseLabelRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateLicenseLabelResponseMsg.typecode) - return response - - # op: RemoveLicenseLabel - def RemoveLicenseLabel(self, request): - if isinstance(request, RemoveLicenseLabelRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveLicenseLabelResponseMsg.typecode) - return response - - # op: Reload - def Reload(self, request): - if isinstance(request, ReloadRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReloadResponseMsg.typecode) - return response - - # op: Rename - def Rename(self, request): - if isinstance(request, RenameRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RenameResponseMsg.typecode) - return response - - # op: Rename_Task - def Rename_Task(self, request): - if isinstance(request, Rename_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(Rename_TaskResponseMsg.typecode) - return response - - # op: Destroy - def Destroy(self, request): - if isinstance(request, DestroyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyResponseMsg.typecode) - return response - - # op: Destroy_Task - def Destroy_Task(self, request): - if isinstance(request, Destroy_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(Destroy_TaskResponseMsg.typecode) - return response - - # op: DestroyNetwork - def DestroyNetwork(self, request): - if isinstance(request, DestroyNetworkRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyNetworkResponseMsg.typecode) - return response - - # op: ValidateHost - def ValidateHost(self, request): - if isinstance(request, ValidateHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ValidateHostResponseMsg.typecode) - return response - - # op: ParseDescriptor - def ParseDescriptor(self, request): - if isinstance(request, ParseDescriptorRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ParseDescriptorResponseMsg.typecode) - return response - - # op: CreateImportSpec - def CreateImportSpec(self, request): - if isinstance(request, CreateImportSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateImportSpecResponseMsg.typecode) - return response - - # op: CreateDescriptor - def CreateDescriptor(self, request): - if isinstance(request, CreateDescriptorRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateDescriptorResponseMsg.typecode) - return response - - # op: QueryPerfProviderSummary - def QueryPerfProviderSummary(self, request): - if isinstance(request, QueryPerfProviderSummaryRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPerfProviderSummaryResponseMsg.typecode) - return response - - # op: QueryAvailablePerfMetric - def QueryAvailablePerfMetric(self, request): - if isinstance(request, QueryAvailablePerfMetricRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryAvailablePerfMetricResponseMsg.typecode) - return response - - # op: QueryPerfCounter - def QueryPerfCounter(self, request): - if isinstance(request, QueryPerfCounterRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPerfCounterResponseMsg.typecode) - return response - - # op: QueryPerfCounterByLevel - def QueryPerfCounterByLevel(self, request): - if isinstance(request, QueryPerfCounterByLevelRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPerfCounterByLevelResponseMsg.typecode) - return response - - # op: QueryPerf - def QueryPerf(self, request): - if isinstance(request, QueryPerfRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPerfResponseMsg.typecode) - return response - - # op: QueryPerfComposite - def QueryPerfComposite(self, request): - if isinstance(request, QueryPerfCompositeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPerfCompositeResponseMsg.typecode) - return response - - # op: CreatePerfInterval - def CreatePerfInterval(self, request): - if isinstance(request, CreatePerfIntervalRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreatePerfIntervalResponseMsg.typecode) - return response - - # op: RemovePerfInterval - def RemovePerfInterval(self, request): - if isinstance(request, RemovePerfIntervalRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemovePerfIntervalResponseMsg.typecode) - return response - - # op: UpdatePerfInterval - def UpdatePerfInterval(self, request): - if isinstance(request, UpdatePerfIntervalRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdatePerfIntervalResponseMsg.typecode) - return response - - # op: GetDatabaseSizeEstimate - def GetDatabaseSizeEstimate(self, request): - if isinstance(request, GetDatabaseSizeEstimateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GetDatabaseSizeEstimateResponseMsg.typecode) - return response - - # op: UpdateConfig - def UpdateConfig(self, request): - if isinstance(request, UpdateConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateConfigResponseMsg.typecode) - return response - - # op: MoveIntoResourcePool - def MoveIntoResourcePool(self, request): - if isinstance(request, MoveIntoResourcePoolRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveIntoResourcePoolResponseMsg.typecode) - return response - - # op: UpdateChildResourceConfiguration - def UpdateChildResourceConfiguration(self, request): - if isinstance(request, UpdateChildResourceConfigurationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateChildResourceConfigurationResponseMsg.typecode) - return response - - # op: CreateResourcePool - def CreateResourcePool(self, request): - if isinstance(request, CreateResourcePoolRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateResourcePoolResponseMsg.typecode) - return response - - # op: DestroyChildren - def DestroyChildren(self, request): - if isinstance(request, DestroyChildrenRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyChildrenResponseMsg.typecode) - return response - - # op: CreateVApp - def CreateVApp(self, request): - if isinstance(request, CreateVAppRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateVAppResponseMsg.typecode) - return response - - # op: CreateChildVM - def CreateChildVM(self, request): - if isinstance(request, CreateChildVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateChildVMResponseMsg.typecode) - return response - - # op: CreateChildVM_Task - def CreateChildVM_Task(self, request): - if isinstance(request, CreateChildVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateChildVM_TaskResponseMsg.typecode) - return response - - # op: RegisterChildVM - def RegisterChildVM(self, request): - if isinstance(request, RegisterChildVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RegisterChildVMResponseMsg.typecode) - return response - - # op: RegisterChildVM_Task - def RegisterChildVM_Task(self, request): - if isinstance(request, RegisterChildVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RegisterChildVM_TaskResponseMsg.typecode) - return response - - # op: ImportVApp - def ImportVApp(self, request): - if isinstance(request, ImportVAppRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ImportVAppResponseMsg.typecode) - return response - - # op: FindByUuid - def FindByUuid(self, request): - if isinstance(request, FindByUuidRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindByUuidResponseMsg.typecode) - return response - - # op: FindByDatastorePath - def FindByDatastorePath(self, request): - if isinstance(request, FindByDatastorePathRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindByDatastorePathResponseMsg.typecode) - return response - - # op: FindByDnsName - def FindByDnsName(self, request): - if isinstance(request, FindByDnsNameRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindByDnsNameResponseMsg.typecode) - return response - - # op: FindByIp - def FindByIp(self, request): - if isinstance(request, FindByIpRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindByIpResponseMsg.typecode) - return response - - # op: FindByInventoryPath - def FindByInventoryPath(self, request): - if isinstance(request, FindByInventoryPathRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindByInventoryPathResponseMsg.typecode) - return response - - # op: FindChild - def FindChild(self, request): - if isinstance(request, FindChildRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindChildResponseMsg.typecode) - return response - - # op: FindAllByUuid - def FindAllByUuid(self, request): - if isinstance(request, FindAllByUuidRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindAllByUuidResponseMsg.typecode) - return response - - # op: FindAllByDnsName - def FindAllByDnsName(self, request): - if isinstance(request, FindAllByDnsNameRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindAllByDnsNameResponseMsg.typecode) - return response - - # op: FindAllByIp - def FindAllByIp(self, request): - if isinstance(request, FindAllByIpRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FindAllByIpResponseMsg.typecode) - return response - - # op: CurrentTime - def CurrentTime(self, request): - if isinstance(request, CurrentTimeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CurrentTimeResponseMsg.typecode) - return response - - # op: RetrieveServiceContent - def RetrieveServiceContent(self, request): - if isinstance(request, RetrieveServiceContentRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveServiceContentResponseMsg.typecode) - return response - - # op: ValidateMigration - def ValidateMigration(self, request): - if isinstance(request, ValidateMigrationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ValidateMigrationResponseMsg.typecode) - return response - - # op: QueryVMotionCompatibility - def QueryVMotionCompatibility(self, request): - if isinstance(request, QueryVMotionCompatibilityRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVMotionCompatibilityResponseMsg.typecode) - return response - - # op: RetrieveProductComponents - def RetrieveProductComponents(self, request): - if isinstance(request, RetrieveProductComponentsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveProductComponentsResponseMsg.typecode) - return response - - # op: UpdateServiceMessage - def UpdateServiceMessage(self, request): - if isinstance(request, UpdateServiceMessageRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateServiceMessageResponseMsg.typecode) - return response - - # op: Login - def Login(self, request): - if isinstance(request, LoginRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(LoginResponseMsg.typecode) - return response - - # op: LoginBySSPI - def LoginBySSPI(self, request): - if isinstance(request, LoginBySSPIRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(LoginBySSPIResponseMsg.typecode) - return response - - # op: Logout - def Logout(self, request): - if isinstance(request, LogoutRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(LogoutResponseMsg.typecode) - return response - - # op: AcquireLocalTicket - def AcquireLocalTicket(self, request): - if isinstance(request, AcquireLocalTicketRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AcquireLocalTicketResponseMsg.typecode) - return response - - # op: TerminateSession - def TerminateSession(self, request): - if isinstance(request, TerminateSessionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(TerminateSessionResponseMsg.typecode) - return response - - # op: SetLocale - def SetLocale(self, request): - if isinstance(request, SetLocaleRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetLocaleResponseMsg.typecode) - return response - - # op: LoginExtensionBySubjectName - def LoginExtensionBySubjectName(self, request): - if isinstance(request, LoginExtensionBySubjectNameRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(LoginExtensionBySubjectNameResponseMsg.typecode) - return response - - # op: ImpersonateUser - def ImpersonateUser(self, request): - if isinstance(request, ImpersonateUserRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ImpersonateUserResponseMsg.typecode) - return response - - # op: SessionIsActive - def SessionIsActive(self, request): - if isinstance(request, SessionIsActiveRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SessionIsActiveResponseMsg.typecode) - return response - - # op: AcquireCloneTicket - def AcquireCloneTicket(self, request): - if isinstance(request, AcquireCloneTicketRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AcquireCloneTicketResponseMsg.typecode) - return response - - # op: CloneSession - def CloneSession(self, request): - if isinstance(request, CloneSessionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CloneSessionResponseMsg.typecode) - return response - - # op: CancelTask - def CancelTask(self, request): - if isinstance(request, CancelTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CancelTaskResponseMsg.typecode) - return response - - # op: UpdateProgress - def UpdateProgress(self, request): - if isinstance(request, UpdateProgressRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateProgressResponseMsg.typecode) - return response - - # op: SetTaskState - def SetTaskState(self, request): - if isinstance(request, SetTaskStateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetTaskStateResponseMsg.typecode) - return response - - # op: SetTaskDescription - def SetTaskDescription(self, request): - if isinstance(request, SetTaskDescriptionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetTaskDescriptionResponseMsg.typecode) - return response - - # op: ReadNextTasks - def ReadNextTasks(self, request): - if isinstance(request, ReadNextTasksRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReadNextTasksResponseMsg.typecode) - return response - - # op: ReadPreviousTasks - def ReadPreviousTasks(self, request): - if isinstance(request, ReadPreviousTasksRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReadPreviousTasksResponseMsg.typecode) - return response - - # op: CreateCollectorForTasks - def CreateCollectorForTasks(self, request): - if isinstance(request, CreateCollectorForTasksRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateCollectorForTasksResponseMsg.typecode) - return response - - # op: CreateTask - def CreateTask(self, request): - if isinstance(request, CreateTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateTaskResponseMsg.typecode) - return response - - # op: RetrieveUserGroups - def RetrieveUserGroups(self, request): - if isinstance(request, RetrieveUserGroupsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveUserGroupsResponseMsg.typecode) - return response - - # op: UpdateVAppConfig - def UpdateVAppConfig(self, request): - if isinstance(request, UpdateVAppConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateVAppConfigResponseMsg.typecode) - return response - - # op: CloneVApp - def CloneVApp(self, request): - if isinstance(request, CloneVAppRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CloneVAppResponseMsg.typecode) - return response - - # op: CloneVApp_Task - def CloneVApp_Task(self, request): - if isinstance(request, CloneVApp_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CloneVApp_TaskResponseMsg.typecode) - return response - - # op: ExportVApp - def ExportVApp(self, request): - if isinstance(request, ExportVAppRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExportVAppResponseMsg.typecode) - return response - - # op: PowerOnVApp - def PowerOnVApp(self, request): - if isinstance(request, PowerOnVAppRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOnVAppResponseMsg.typecode) - return response - - # op: PowerOnVApp_Task - def PowerOnVApp_Task(self, request): - if isinstance(request, PowerOnVApp_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOnVApp_TaskResponseMsg.typecode) - return response - - # op: PowerOffVApp - def PowerOffVApp(self, request): - if isinstance(request, PowerOffVAppRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOffVAppResponseMsg.typecode) - return response - - # op: PowerOffVApp_Task - def PowerOffVApp_Task(self, request): - if isinstance(request, PowerOffVApp_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOffVApp_TaskResponseMsg.typecode) - return response - - # op: unregisterVApp - def unregisterVApp(self, request): - if isinstance(request, unregisterVAppRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(unregisterVAppResponseMsg.typecode) - return response - - # op: unregisterVApp_Task - def unregisterVApp_Task(self, request): - if isinstance(request, unregisterVApp_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(unregisterVApp_TaskResponseMsg.typecode) - return response - - # op: CreateVirtualDisk - def CreateVirtualDisk(self, request): - if isinstance(request, CreateVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateVirtualDiskResponseMsg.typecode) - return response - - # op: CreateVirtualDisk_Task - def CreateVirtualDisk_Task(self, request): - if isinstance(request, CreateVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: DeleteVirtualDisk - def DeleteVirtualDisk(self, request): - if isinstance(request, DeleteVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DeleteVirtualDiskResponseMsg.typecode) - return response - - # op: DeleteVirtualDisk_Task - def DeleteVirtualDisk_Task(self, request): - if isinstance(request, DeleteVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DeleteVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: MoveVirtualDisk - def MoveVirtualDisk(self, request): - if isinstance(request, MoveVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveVirtualDiskResponseMsg.typecode) - return response - - # op: MoveVirtualDisk_Task - def MoveVirtualDisk_Task(self, request): - if isinstance(request, MoveVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MoveVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: CopyVirtualDisk - def CopyVirtualDisk(self, request): - if isinstance(request, CopyVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CopyVirtualDiskResponseMsg.typecode) - return response - - # op: CopyVirtualDisk_Task - def CopyVirtualDisk_Task(self, request): - if isinstance(request, CopyVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CopyVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: ExtendVirtualDisk - def ExtendVirtualDisk(self, request): - if isinstance(request, ExtendVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExtendVirtualDiskResponseMsg.typecode) - return response - - # op: ExtendVirtualDisk_Task - def ExtendVirtualDisk_Task(self, request): - if isinstance(request, ExtendVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExtendVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: QueryVirtualDiskFragmentation - def QueryVirtualDiskFragmentation(self, request): - if isinstance(request, QueryVirtualDiskFragmentationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVirtualDiskFragmentationResponseMsg.typecode) - return response - - # op: DefragmentVirtualDisk - def DefragmentVirtualDisk(self, request): - if isinstance(request, DefragmentVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DefragmentVirtualDiskResponseMsg.typecode) - return response - - # op: DefragmentVirtualDisk_Task - def DefragmentVirtualDisk_Task(self, request): - if isinstance(request, DefragmentVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DefragmentVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: ShrinkVirtualDisk - def ShrinkVirtualDisk(self, request): - if isinstance(request, ShrinkVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ShrinkVirtualDiskResponseMsg.typecode) - return response - - # op: ShrinkVirtualDisk_Task - def ShrinkVirtualDisk_Task(self, request): - if isinstance(request, ShrinkVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ShrinkVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: InflateVirtualDisk - def InflateVirtualDisk(self, request): - if isinstance(request, InflateVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(InflateVirtualDiskResponseMsg.typecode) - return response - - # op: InflateVirtualDisk_Task - def InflateVirtualDisk_Task(self, request): - if isinstance(request, InflateVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(InflateVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: EagerZeroVirtualDisk - def EagerZeroVirtualDisk(self, request): - if isinstance(request, EagerZeroVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EagerZeroVirtualDiskResponseMsg.typecode) - return response - - # op: EagerZeroVirtualDisk_Task - def EagerZeroVirtualDisk_Task(self, request): - if isinstance(request, EagerZeroVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EagerZeroVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: ZeroFillVirtualDisk - def ZeroFillVirtualDisk(self, request): - if isinstance(request, ZeroFillVirtualDiskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ZeroFillVirtualDiskResponseMsg.typecode) - return response - - # op: ZeroFillVirtualDisk_Task - def ZeroFillVirtualDisk_Task(self, request): - if isinstance(request, ZeroFillVirtualDisk_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ZeroFillVirtualDisk_TaskResponseMsg.typecode) - return response - - # op: SetVirtualDiskUuid - def SetVirtualDiskUuid(self, request): - if isinstance(request, SetVirtualDiskUuidRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetVirtualDiskUuidResponseMsg.typecode) - return response - - # op: QueryVirtualDiskUuid - def QueryVirtualDiskUuid(self, request): - if isinstance(request, QueryVirtualDiskUuidRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVirtualDiskUuidResponseMsg.typecode) - return response - - # op: QueryVirtualDiskGeometry - def QueryVirtualDiskGeometry(self, request): - if isinstance(request, QueryVirtualDiskGeometryRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVirtualDiskGeometryResponseMsg.typecode) - return response - - # op: RefreshStorageInfo - def RefreshStorageInfo(self, request): - if isinstance(request, RefreshStorageInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshStorageInfoResponseMsg.typecode) - return response - - # op: CreateSnapshot - def CreateSnapshot(self, request): - if isinstance(request, CreateSnapshotRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateSnapshotResponseMsg.typecode) - return response - - # op: CreateSnapshot_Task - def CreateSnapshot_Task(self, request): - if isinstance(request, CreateSnapshot_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateSnapshot_TaskResponseMsg.typecode) - return response - - # op: RevertToCurrentSnapshot - def RevertToCurrentSnapshot(self, request): - if isinstance(request, RevertToCurrentSnapshotRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RevertToCurrentSnapshotResponseMsg.typecode) - return response - - # op: RevertToCurrentSnapshot_Task - def RevertToCurrentSnapshot_Task(self, request): - if isinstance(request, RevertToCurrentSnapshot_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RevertToCurrentSnapshot_TaskResponseMsg.typecode) - return response - - # op: RemoveAllSnapshots - def RemoveAllSnapshots(self, request): - if isinstance(request, RemoveAllSnapshotsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveAllSnapshotsResponseMsg.typecode) - return response - - # op: RemoveAllSnapshots_Task - def RemoveAllSnapshots_Task(self, request): - if isinstance(request, RemoveAllSnapshots_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveAllSnapshots_TaskResponseMsg.typecode) - return response - - # op: ReconfigVM - def ReconfigVM(self, request): - if isinstance(request, ReconfigVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigVMResponseMsg.typecode) - return response - - # op: ReconfigVM_Task - def ReconfigVM_Task(self, request): - if isinstance(request, ReconfigVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigVM_TaskResponseMsg.typecode) - return response - - # op: UpgradeVM - def UpgradeVM(self, request): - if isinstance(request, UpgradeVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpgradeVMResponseMsg.typecode) - return response - - # op: UpgradeVM_Task - def UpgradeVM_Task(self, request): - if isinstance(request, UpgradeVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpgradeVM_TaskResponseMsg.typecode) - return response - - # op: ExtractOvfEnvironment - def ExtractOvfEnvironment(self, request): - if isinstance(request, ExtractOvfEnvironmentRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExtractOvfEnvironmentResponseMsg.typecode) - return response - - # op: PowerOnVM - def PowerOnVM(self, request): - if isinstance(request, PowerOnVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOnVMResponseMsg.typecode) - return response - - # op: PowerOnVM_Task - def PowerOnVM_Task(self, request): - if isinstance(request, PowerOnVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOnVM_TaskResponseMsg.typecode) - return response - - # op: PowerOffVM - def PowerOffVM(self, request): - if isinstance(request, PowerOffVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOffVMResponseMsg.typecode) - return response - - # op: PowerOffVM_Task - def PowerOffVM_Task(self, request): - if isinstance(request, PowerOffVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PowerOffVM_TaskResponseMsg.typecode) - return response - - # op: SuspendVM - def SuspendVM(self, request): - if isinstance(request, SuspendVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SuspendVMResponseMsg.typecode) - return response - - # op: SuspendVM_Task - def SuspendVM_Task(self, request): - if isinstance(request, SuspendVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SuspendVM_TaskResponseMsg.typecode) - return response - - # op: ResetVM - def ResetVM(self, request): - if isinstance(request, ResetVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetVMResponseMsg.typecode) - return response - - # op: ResetVM_Task - def ResetVM_Task(self, request): - if isinstance(request, ResetVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetVM_TaskResponseMsg.typecode) - return response - - # op: ShutdownGuest - def ShutdownGuest(self, request): - if isinstance(request, ShutdownGuestRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ShutdownGuestResponseMsg.typecode) - return response - - # op: RebootGuest - def RebootGuest(self, request): - if isinstance(request, RebootGuestRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RebootGuestResponseMsg.typecode) - return response - - # op: StandbyGuest - def StandbyGuest(self, request): - if isinstance(request, StandbyGuestRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StandbyGuestResponseMsg.typecode) - return response - - # op: AnswerVM - def AnswerVM(self, request): - if isinstance(request, AnswerVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AnswerVMResponseMsg.typecode) - return response - - # op: CustomizeVM - def CustomizeVM(self, request): - if isinstance(request, CustomizeVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CustomizeVMResponseMsg.typecode) - return response - - # op: CustomizeVM_Task - def CustomizeVM_Task(self, request): - if isinstance(request, CustomizeVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CustomizeVM_TaskResponseMsg.typecode) - return response - - # op: CheckCustomizationSpec - def CheckCustomizationSpec(self, request): - if isinstance(request, CheckCustomizationSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckCustomizationSpecResponseMsg.typecode) - return response - - # op: MigrateVM - def MigrateVM(self, request): - if isinstance(request, MigrateVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MigrateVMResponseMsg.typecode) - return response - - # op: MigrateVM_Task - def MigrateVM_Task(self, request): - if isinstance(request, MigrateVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MigrateVM_TaskResponseMsg.typecode) - return response - - # op: RelocateVM - def RelocateVM(self, request): - if isinstance(request, RelocateVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RelocateVMResponseMsg.typecode) - return response - - # op: RelocateVM_Task - def RelocateVM_Task(self, request): - if isinstance(request, RelocateVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RelocateVM_TaskResponseMsg.typecode) - return response - - # op: CloneVM - def CloneVM(self, request): - if isinstance(request, CloneVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CloneVMResponseMsg.typecode) - return response - - # op: CloneVM_Task - def CloneVM_Task(self, request): - if isinstance(request, CloneVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CloneVM_TaskResponseMsg.typecode) - return response - - # op: ExportVm - def ExportVm(self, request): - if isinstance(request, ExportVmRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExportVmResponseMsg.typecode) - return response - - # op: MarkAsTemplate - def MarkAsTemplate(self, request): - if isinstance(request, MarkAsTemplateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MarkAsTemplateResponseMsg.typecode) - return response - - # op: MarkAsVirtualMachine - def MarkAsVirtualMachine(self, request): - if isinstance(request, MarkAsVirtualMachineRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MarkAsVirtualMachineResponseMsg.typecode) - return response - - # op: UnregisterVM - def UnregisterVM(self, request): - if isinstance(request, UnregisterVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UnregisterVMResponseMsg.typecode) - return response - - # op: ResetGuestInformation - def ResetGuestInformation(self, request): - if isinstance(request, ResetGuestInformationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetGuestInformationResponseMsg.typecode) - return response - - # op: MountToolsInstaller - def MountToolsInstaller(self, request): - if isinstance(request, MountToolsInstallerRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MountToolsInstallerResponseMsg.typecode) - return response - - # op: UnmountToolsInstaller - def UnmountToolsInstaller(self, request): - if isinstance(request, UnmountToolsInstallerRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UnmountToolsInstallerResponseMsg.typecode) - return response - - # op: UpgradeTools - def UpgradeTools(self, request): - if isinstance(request, UpgradeToolsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpgradeToolsResponseMsg.typecode) - return response - - # op: UpgradeTools_Task - def UpgradeTools_Task(self, request): - if isinstance(request, UpgradeTools_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpgradeTools_TaskResponseMsg.typecode) - return response - - # op: AcquireMksTicket - def AcquireMksTicket(self, request): - if isinstance(request, AcquireMksTicketRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AcquireMksTicketResponseMsg.typecode) - return response - - # op: SetScreenResolution - def SetScreenResolution(self, request): - if isinstance(request, SetScreenResolutionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetScreenResolutionResponseMsg.typecode) - return response - - # op: DefragmentAllDisks - def DefragmentAllDisks(self, request): - if isinstance(request, DefragmentAllDisksRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DefragmentAllDisksResponseMsg.typecode) - return response - - # op: CreateSecondaryVM - def CreateSecondaryVM(self, request): - if isinstance(request, CreateSecondaryVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateSecondaryVMResponseMsg.typecode) - return response - - # op: CreateSecondaryVM_Task - def CreateSecondaryVM_Task(self, request): - if isinstance(request, CreateSecondaryVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateSecondaryVM_TaskResponseMsg.typecode) - return response - - # op: TurnOffFaultToleranceForVM - def TurnOffFaultToleranceForVM(self, request): - if isinstance(request, TurnOffFaultToleranceForVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(TurnOffFaultToleranceForVMResponseMsg.typecode) - return response - - # op: TurnOffFaultToleranceForVM_Task - def TurnOffFaultToleranceForVM_Task(self, request): - if isinstance(request, TurnOffFaultToleranceForVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(TurnOffFaultToleranceForVM_TaskResponseMsg.typecode) - return response - - # op: MakePrimaryVM - def MakePrimaryVM(self, request): - if isinstance(request, MakePrimaryVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MakePrimaryVMResponseMsg.typecode) - return response - - # op: MakePrimaryVM_Task - def MakePrimaryVM_Task(self, request): - if isinstance(request, MakePrimaryVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(MakePrimaryVM_TaskResponseMsg.typecode) - return response - - # op: TerminateFaultTolerantVM - def TerminateFaultTolerantVM(self, request): - if isinstance(request, TerminateFaultTolerantVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(TerminateFaultTolerantVMResponseMsg.typecode) - return response - - # op: TerminateFaultTolerantVM_Task - def TerminateFaultTolerantVM_Task(self, request): - if isinstance(request, TerminateFaultTolerantVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(TerminateFaultTolerantVM_TaskResponseMsg.typecode) - return response - - # op: DisableSecondaryVM - def DisableSecondaryVM(self, request): - if isinstance(request, DisableSecondaryVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisableSecondaryVMResponseMsg.typecode) - return response - - # op: DisableSecondaryVM_Task - def DisableSecondaryVM_Task(self, request): - if isinstance(request, DisableSecondaryVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisableSecondaryVM_TaskResponseMsg.typecode) - return response - - # op: EnableSecondaryVM - def EnableSecondaryVM(self, request): - if isinstance(request, EnableSecondaryVMRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnableSecondaryVMResponseMsg.typecode) - return response - - # op: EnableSecondaryVM_Task - def EnableSecondaryVM_Task(self, request): - if isinstance(request, EnableSecondaryVM_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnableSecondaryVM_TaskResponseMsg.typecode) - return response - - # op: SetDisplayTopology - def SetDisplayTopology(self, request): - if isinstance(request, SetDisplayTopologyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetDisplayTopologyResponseMsg.typecode) - return response - - # op: StartRecording - def StartRecording(self, request): - if isinstance(request, StartRecordingRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StartRecordingResponseMsg.typecode) - return response - - # op: StartRecording_Task - def StartRecording_Task(self, request): - if isinstance(request, StartRecording_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StartRecording_TaskResponseMsg.typecode) - return response - - # op: StopRecording - def StopRecording(self, request): - if isinstance(request, StopRecordingRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StopRecordingResponseMsg.typecode) - return response - - # op: StopRecording_Task - def StopRecording_Task(self, request): - if isinstance(request, StopRecording_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StopRecording_TaskResponseMsg.typecode) - return response - - # op: StartReplaying - def StartReplaying(self, request): - if isinstance(request, StartReplayingRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StartReplayingResponseMsg.typecode) - return response - - # op: StartReplaying_Task - def StartReplaying_Task(self, request): - if isinstance(request, StartReplaying_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StartReplaying_TaskResponseMsg.typecode) - return response - - # op: StopReplaying - def StopReplaying(self, request): - if isinstance(request, StopReplayingRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StopReplayingResponseMsg.typecode) - return response - - # op: StopReplaying_Task - def StopReplaying_Task(self, request): - if isinstance(request, StopReplaying_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StopReplaying_TaskResponseMsg.typecode) - return response - - # op: PromoteDisks - def PromoteDisks(self, request): - if isinstance(request, PromoteDisksRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PromoteDisksResponseMsg.typecode) - return response - - # op: PromoteDisks_Task - def PromoteDisks_Task(self, request): - if isinstance(request, PromoteDisks_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PromoteDisks_TaskResponseMsg.typecode) - return response - - # op: CreateScreenshot - def CreateScreenshot(self, request): - if isinstance(request, CreateScreenshotRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateScreenshotResponseMsg.typecode) - return response - - # op: CreateScreenshot_Task - def CreateScreenshot_Task(self, request): - if isinstance(request, CreateScreenshot_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateScreenshot_TaskResponseMsg.typecode) - return response - - # op: QueryChangedDiskAreas - def QueryChangedDiskAreas(self, request): - if isinstance(request, QueryChangedDiskAreasRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryChangedDiskAreasResponseMsg.typecode) - return response - - # op: QueryUnownedFiles - def QueryUnownedFiles(self, request): - if isinstance(request, QueryUnownedFilesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryUnownedFilesResponseMsg.typecode) - return response - - # op: RemoveAlarm - def RemoveAlarm(self, request): - if isinstance(request, RemoveAlarmRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveAlarmResponseMsg.typecode) - return response - - # op: ReconfigureAlarm - def ReconfigureAlarm(self, request): - if isinstance(request, ReconfigureAlarmRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureAlarmResponseMsg.typecode) - return response - - # op: CreateAlarm - def CreateAlarm(self, request): - if isinstance(request, CreateAlarmRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateAlarmResponseMsg.typecode) - return response - - # op: GetAlarm - def GetAlarm(self, request): - if isinstance(request, GetAlarmRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GetAlarmResponseMsg.typecode) - return response - - # op: GetAlarmActionsEnabled - def GetAlarmActionsEnabled(self, request): - if isinstance(request, GetAlarmActionsEnabledRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GetAlarmActionsEnabledResponseMsg.typecode) - return response - - # op: SetAlarmActionsEnabled - def SetAlarmActionsEnabled(self, request): - if isinstance(request, SetAlarmActionsEnabledRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetAlarmActionsEnabledResponseMsg.typecode) - return response - - # op: GetAlarmState - def GetAlarmState(self, request): - if isinstance(request, GetAlarmStateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(GetAlarmStateResponseMsg.typecode) - return response - - # op: AcknowledgeAlarm - def AcknowledgeAlarm(self, request): - if isinstance(request, AcknowledgeAlarmRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AcknowledgeAlarmResponseMsg.typecode) - return response - - # op: DVPortgroupReconfigure - def DVPortgroupReconfigure(self, request): - if isinstance(request, DVPortgroupReconfigureRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVPortgroupReconfigureResponseMsg.typecode) - return response - - # op: DVSManagerQueryAvailableSwitchSpec - def DVSManagerQueryAvailableSwitchSpec(self, request): - if isinstance(request, DVSManagerQueryAvailableSwitchSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSManagerQueryAvailableSwitchSpecResponseMsg.typecode) - return response - - # op: DVSManagerQueryCompatibleHostForNewDvs - def DVSManagerQueryCompatibleHostForNewDvs(self, request): - if isinstance(request, DVSManagerQueryCompatibleHostForNewDvsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSManagerQueryCompatibleHostForNewDvsResponseMsg.typecode) - return response - - # op: DVSManagerQueryCompatibleHostForExistingDvs - def DVSManagerQueryCompatibleHostForExistingDvs(self, request): - if isinstance(request, DVSManagerQueryCompatibleHostForExistingDvsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSManagerQueryCompatibleHostForExistingDvsResponseMsg.typecode) - return response - - # op: DVSManagerQueryCompatibleHostSpec - def DVSManagerQueryCompatibleHostSpec(self, request): - if isinstance(request, DVSManagerQueryCompatibleHostSpecRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSManagerQueryCompatibleHostSpecResponseMsg.typecode) - return response - - # op: DVSManagerQuerySwitchByUuid - def DVSManagerQuerySwitchByUuid(self, request): - if isinstance(request, DVSManagerQuerySwitchByUuidRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSManagerQuerySwitchByUuidResponseMsg.typecode) - return response - - # op: DVSManagerQueryDvsConfigTarget - def DVSManagerQueryDvsConfigTarget(self, request): - if isinstance(request, DVSManagerQueryDvsConfigTargetRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DVSManagerQueryDvsConfigTargetResponseMsg.typecode) - return response - - # op: ReadNextEvents - def ReadNextEvents(self, request): - if isinstance(request, ReadNextEventsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReadNextEventsResponseMsg.typecode) - return response - - # op: ReadPreviousEvents - def ReadPreviousEvents(self, request): - if isinstance(request, ReadPreviousEventsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReadPreviousEventsResponseMsg.typecode) - return response - - # op: RetrieveArgumentDescription - def RetrieveArgumentDescription(self, request): - if isinstance(request, RetrieveArgumentDescriptionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveArgumentDescriptionResponseMsg.typecode) - return response - - # op: CreateCollectorForEvents - def CreateCollectorForEvents(self, request): - if isinstance(request, CreateCollectorForEventsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateCollectorForEventsResponseMsg.typecode) - return response - - # op: LogUserEvent - def LogUserEvent(self, request): - if isinstance(request, LogUserEventRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(LogUserEventResponseMsg.typecode) - return response - - # op: QueryEvents - def QueryEvents(self, request): - if isinstance(request, QueryEventsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryEventsResponseMsg.typecode) - return response - - # op: PostEvent - def PostEvent(self, request): - if isinstance(request, PostEventRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(PostEventResponseMsg.typecode) - return response - - # op: ReconfigureAutostart - def ReconfigureAutostart(self, request): - if isinstance(request, ReconfigureAutostartRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureAutostartResponseMsg.typecode) - return response - - # op: AutoStartPowerOn - def AutoStartPowerOn(self, request): - if isinstance(request, AutoStartPowerOnRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AutoStartPowerOnResponseMsg.typecode) - return response - - # op: AutoStartPowerOff - def AutoStartPowerOff(self, request): - if isinstance(request, AutoStartPowerOffRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AutoStartPowerOffResponseMsg.typecode) - return response - - # op: QueryBootDevices - def QueryBootDevices(self, request): - if isinstance(request, QueryBootDevicesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryBootDevicesResponseMsg.typecode) - return response - - # op: UpdateBootDevice - def UpdateBootDevice(self, request): - if isinstance(request, UpdateBootDeviceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateBootDeviceResponseMsg.typecode) - return response - - # op: EnableHyperThreading - def EnableHyperThreading(self, request): - if isinstance(request, EnableHyperThreadingRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnableHyperThreadingResponseMsg.typecode) - return response - - # op: DisableHyperThreading - def DisableHyperThreading(self, request): - if isinstance(request, DisableHyperThreadingRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisableHyperThreadingResponseMsg.typecode) - return response - - # op: SearchDatastore - def SearchDatastore(self, request): - if isinstance(request, SearchDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SearchDatastoreResponseMsg.typecode) - return response - - # op: SearchDatastore_Task - def SearchDatastore_Task(self, request): - if isinstance(request, SearchDatastore_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SearchDatastore_TaskResponseMsg.typecode) - return response - - # op: SearchDatastoreSubFolders - def SearchDatastoreSubFolders(self, request): - if isinstance(request, SearchDatastoreSubFoldersRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SearchDatastoreSubFoldersResponseMsg.typecode) - return response - - # op: SearchDatastoreSubFolders_Task - def SearchDatastoreSubFolders_Task(self, request): - if isinstance(request, SearchDatastoreSubFolders_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SearchDatastoreSubFolders_TaskResponseMsg.typecode) - return response - - # op: DeleteFile - def DeleteFile(self, request): - if isinstance(request, DeleteFileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DeleteFileResponseMsg.typecode) - return response - - # op: UpdateLocalSwapDatastore - def UpdateLocalSwapDatastore(self, request): - if isinstance(request, UpdateLocalSwapDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateLocalSwapDatastoreResponseMsg.typecode) - return response - - # op: QueryAvailableDisksForVmfs - def QueryAvailableDisksForVmfs(self, request): - if isinstance(request, QueryAvailableDisksForVmfsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryAvailableDisksForVmfsResponseMsg.typecode) - return response - - # op: QueryVmfsDatastoreCreateOptions - def QueryVmfsDatastoreCreateOptions(self, request): - if isinstance(request, QueryVmfsDatastoreCreateOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVmfsDatastoreCreateOptionsResponseMsg.typecode) - return response - - # op: CreateVmfsDatastore - def CreateVmfsDatastore(self, request): - if isinstance(request, CreateVmfsDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateVmfsDatastoreResponseMsg.typecode) - return response - - # op: QueryVmfsDatastoreExtendOptions - def QueryVmfsDatastoreExtendOptions(self, request): - if isinstance(request, QueryVmfsDatastoreExtendOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVmfsDatastoreExtendOptionsResponseMsg.typecode) - return response - - # op: QueryVmfsDatastoreExpandOptions - def QueryVmfsDatastoreExpandOptions(self, request): - if isinstance(request, QueryVmfsDatastoreExpandOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVmfsDatastoreExpandOptionsResponseMsg.typecode) - return response - - # op: ExtendVmfsDatastore - def ExtendVmfsDatastore(self, request): - if isinstance(request, ExtendVmfsDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExtendVmfsDatastoreResponseMsg.typecode) - return response - - # op: ExpandVmfsDatastore - def ExpandVmfsDatastore(self, request): - if isinstance(request, ExpandVmfsDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExpandVmfsDatastoreResponseMsg.typecode) - return response - - # op: CreateNasDatastore - def CreateNasDatastore(self, request): - if isinstance(request, CreateNasDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateNasDatastoreResponseMsg.typecode) - return response - - # op: CreateLocalDatastore - def CreateLocalDatastore(self, request): - if isinstance(request, CreateLocalDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateLocalDatastoreResponseMsg.typecode) - return response - - # op: RemoveDatastore - def RemoveDatastore(self, request): - if isinstance(request, RemoveDatastoreRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveDatastoreResponseMsg.typecode) - return response - - # op: ConfigureDatastorePrincipal - def ConfigureDatastorePrincipal(self, request): - if isinstance(request, ConfigureDatastorePrincipalRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ConfigureDatastorePrincipalResponseMsg.typecode) - return response - - # op: QueryUnresolvedVmfsVolumes - def QueryUnresolvedVmfsVolumes(self, request): - if isinstance(request, QueryUnresolvedVmfsVolumesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryUnresolvedVmfsVolumesResponseMsg.typecode) - return response - - # op: ResignatureUnresolvedVmfsVolume - def ResignatureUnresolvedVmfsVolume(self, request): - if isinstance(request, ResignatureUnresolvedVmfsVolumeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResignatureUnresolvedVmfsVolumeResponseMsg.typecode) - return response - - # op: ResignatureUnresolvedVmfsVolume_Task - def ResignatureUnresolvedVmfsVolume_Task(self, request): - if isinstance(request, ResignatureUnresolvedVmfsVolume_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResignatureUnresolvedVmfsVolume_TaskResponseMsg.typecode) - return response - - # op: UpdateDateTimeConfig - def UpdateDateTimeConfig(self, request): - if isinstance(request, UpdateDateTimeConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateDateTimeConfigResponseMsg.typecode) - return response - - # op: QueryAvailableTimeZones - def QueryAvailableTimeZones(self, request): - if isinstance(request, QueryAvailableTimeZonesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryAvailableTimeZonesResponseMsg.typecode) - return response - - # op: QueryDateTime - def QueryDateTime(self, request): - if isinstance(request, QueryDateTimeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryDateTimeResponseMsg.typecode) - return response - - # op: UpdateDateTime - def UpdateDateTime(self, request): - if isinstance(request, UpdateDateTimeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateDateTimeResponseMsg.typecode) - return response - - # op: RefreshDateTimeSystem - def RefreshDateTimeSystem(self, request): - if isinstance(request, RefreshDateTimeSystemRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshDateTimeSystemResponseMsg.typecode) - return response - - # op: QueryAvailablePartition - def QueryAvailablePartition(self, request): - if isinstance(request, QueryAvailablePartitionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryAvailablePartitionResponseMsg.typecode) - return response - - # op: SelectActivePartition - def SelectActivePartition(self, request): - if isinstance(request, SelectActivePartitionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SelectActivePartitionResponseMsg.typecode) - return response - - # op: QueryPartitionCreateOptions - def QueryPartitionCreateOptions(self, request): - if isinstance(request, QueryPartitionCreateOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPartitionCreateOptionsResponseMsg.typecode) - return response - - # op: QueryPartitionCreateDesc - def QueryPartitionCreateDesc(self, request): - if isinstance(request, QueryPartitionCreateDescRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPartitionCreateDescResponseMsg.typecode) - return response - - # op: CreateDiagnosticPartition - def CreateDiagnosticPartition(self, request): - if isinstance(request, CreateDiagnosticPartitionRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateDiagnosticPartitionResponseMsg.typecode) - return response - - # op: UpdateDefaultPolicy - def UpdateDefaultPolicy(self, request): - if isinstance(request, UpdateDefaultPolicyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateDefaultPolicyResponseMsg.typecode) - return response - - # op: EnableRuleset - def EnableRuleset(self, request): - if isinstance(request, EnableRulesetRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnableRulesetResponseMsg.typecode) - return response - - # op: DisableRuleset - def DisableRuleset(self, request): - if isinstance(request, DisableRulesetRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisableRulesetResponseMsg.typecode) - return response - - # op: RefreshFirewall - def RefreshFirewall(self, request): - if isinstance(request, RefreshFirewallRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshFirewallResponseMsg.typecode) - return response - - # op: ResetFirmwareToFactoryDefaults - def ResetFirmwareToFactoryDefaults(self, request): - if isinstance(request, ResetFirmwareToFactoryDefaultsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetFirmwareToFactoryDefaultsResponseMsg.typecode) - return response - - # op: BackupFirmwareConfiguration - def BackupFirmwareConfiguration(self, request): - if isinstance(request, BackupFirmwareConfigurationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(BackupFirmwareConfigurationResponseMsg.typecode) - return response - - # op: QueryFirmwareConfigUploadURL - def QueryFirmwareConfigUploadURL(self, request): - if isinstance(request, QueryFirmwareConfigUploadURLRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryFirmwareConfigUploadURLResponseMsg.typecode) - return response - - # op: RestoreFirmwareConfiguration - def RestoreFirmwareConfiguration(self, request): - if isinstance(request, RestoreFirmwareConfigurationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RestoreFirmwareConfigurationResponseMsg.typecode) - return response - - # op: RefreshHealthStatusSystem - def RefreshHealthStatusSystem(self, request): - if isinstance(request, RefreshHealthStatusSystemRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshHealthStatusSystemResponseMsg.typecode) - return response - - # op: ResetSystemHealthInfo - def ResetSystemHealthInfo(self, request): - if isinstance(request, ResetSystemHealthInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetSystemHealthInfoResponseMsg.typecode) - return response - - # op: QueryModules - def QueryModules(self, request): - if isinstance(request, QueryModulesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryModulesResponseMsg.typecode) - return response - - # op: UpdateModuleOptionString - def UpdateModuleOptionString(self, request): - if isinstance(request, UpdateModuleOptionStringRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateModuleOptionStringResponseMsg.typecode) - return response - - # op: QueryConfiguredModuleOptionString - def QueryConfiguredModuleOptionString(self, request): - if isinstance(request, QueryConfiguredModuleOptionStringRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryConfiguredModuleOptionStringResponseMsg.typecode) - return response - - # op: CreateUser - def CreateUser(self, request): - if isinstance(request, CreateUserRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateUserResponseMsg.typecode) - return response - - # op: UpdateUser - def UpdateUser(self, request): - if isinstance(request, UpdateUserRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateUserResponseMsg.typecode) - return response - - # op: CreateGroup - def CreateGroup(self, request): - if isinstance(request, CreateGroupRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateGroupResponseMsg.typecode) - return response - - # op: RemoveUser - def RemoveUser(self, request): - if isinstance(request, RemoveUserRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveUserResponseMsg.typecode) - return response - - # op: RemoveGroup - def RemoveGroup(self, request): - if isinstance(request, RemoveGroupRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveGroupResponseMsg.typecode) - return response - - # op: AssignUserToGroup - def AssignUserToGroup(self, request): - if isinstance(request, AssignUserToGroupRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AssignUserToGroupResponseMsg.typecode) - return response - - # op: UnassignUserFromGroup - def UnassignUserFromGroup(self, request): - if isinstance(request, UnassignUserFromGroupRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UnassignUserFromGroupResponseMsg.typecode) - return response - - # op: ReconfigureServiceConsoleReservation - def ReconfigureServiceConsoleReservation(self, request): - if isinstance(request, ReconfigureServiceConsoleReservationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureServiceConsoleReservationResponseMsg.typecode) - return response - - # op: ReconfigureVirtualMachineReservation - def ReconfigureVirtualMachineReservation(self, request): - if isinstance(request, ReconfigureVirtualMachineReservationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureVirtualMachineReservationResponseMsg.typecode) - return response - - # op: UpdateNetworkConfig - def UpdateNetworkConfig(self, request): - if isinstance(request, UpdateNetworkConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateNetworkConfigResponseMsg.typecode) - return response - - # op: UpdateDnsConfig - def UpdateDnsConfig(self, request): - if isinstance(request, UpdateDnsConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateDnsConfigResponseMsg.typecode) - return response - - # op: UpdateIpRouteConfig - def UpdateIpRouteConfig(self, request): - if isinstance(request, UpdateIpRouteConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateIpRouteConfigResponseMsg.typecode) - return response - - # op: UpdateConsoleIpRouteConfig - def UpdateConsoleIpRouteConfig(self, request): - if isinstance(request, UpdateConsoleIpRouteConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateConsoleIpRouteConfigResponseMsg.typecode) - return response - - # op: UpdateIpRouteTableConfig - def UpdateIpRouteTableConfig(self, request): - if isinstance(request, UpdateIpRouteTableConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateIpRouteTableConfigResponseMsg.typecode) - return response - - # op: AddVirtualSwitch - def AddVirtualSwitch(self, request): - if isinstance(request, AddVirtualSwitchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddVirtualSwitchResponseMsg.typecode) - return response - - # op: RemoveVirtualSwitch - def RemoveVirtualSwitch(self, request): - if isinstance(request, RemoveVirtualSwitchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveVirtualSwitchResponseMsg.typecode) - return response - - # op: UpdateVirtualSwitch - def UpdateVirtualSwitch(self, request): - if isinstance(request, UpdateVirtualSwitchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateVirtualSwitchResponseMsg.typecode) - return response - - # op: AddPortGroup - def AddPortGroup(self, request): - if isinstance(request, AddPortGroupRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddPortGroupResponseMsg.typecode) - return response - - # op: RemovePortGroup - def RemovePortGroup(self, request): - if isinstance(request, RemovePortGroupRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemovePortGroupResponseMsg.typecode) - return response - - # op: UpdatePortGroup - def UpdatePortGroup(self, request): - if isinstance(request, UpdatePortGroupRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdatePortGroupResponseMsg.typecode) - return response - - # op: UpdatePhysicalNicLinkSpeed - def UpdatePhysicalNicLinkSpeed(self, request): - if isinstance(request, UpdatePhysicalNicLinkSpeedRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdatePhysicalNicLinkSpeedResponseMsg.typecode) - return response - - # op: QueryNetworkHint - def QueryNetworkHint(self, request): - if isinstance(request, QueryNetworkHintRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryNetworkHintResponseMsg.typecode) - return response - - # op: AddVirtualNic - def AddVirtualNic(self, request): - if isinstance(request, AddVirtualNicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddVirtualNicResponseMsg.typecode) - return response - - # op: RemoveVirtualNic - def RemoveVirtualNic(self, request): - if isinstance(request, RemoveVirtualNicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveVirtualNicResponseMsg.typecode) - return response - - # op: UpdateVirtualNic - def UpdateVirtualNic(self, request): - if isinstance(request, UpdateVirtualNicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateVirtualNicResponseMsg.typecode) - return response - - # op: AddServiceConsoleVirtualNic - def AddServiceConsoleVirtualNic(self, request): - if isinstance(request, AddServiceConsoleVirtualNicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddServiceConsoleVirtualNicResponseMsg.typecode) - return response - - # op: RemoveServiceConsoleVirtualNic - def RemoveServiceConsoleVirtualNic(self, request): - if isinstance(request, RemoveServiceConsoleVirtualNicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveServiceConsoleVirtualNicResponseMsg.typecode) - return response - - # op: UpdateServiceConsoleVirtualNic - def UpdateServiceConsoleVirtualNic(self, request): - if isinstance(request, UpdateServiceConsoleVirtualNicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateServiceConsoleVirtualNicResponseMsg.typecode) - return response - - # op: RestartServiceConsoleVirtualNic - def RestartServiceConsoleVirtualNic(self, request): - if isinstance(request, RestartServiceConsoleVirtualNicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RestartServiceConsoleVirtualNicResponseMsg.typecode) - return response - - # op: RefreshNetworkSystem - def RefreshNetworkSystem(self, request): - if isinstance(request, RefreshNetworkSystemRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshNetworkSystemResponseMsg.typecode) - return response - - # op: CheckHostPatch - def CheckHostPatch(self, request): - if isinstance(request, CheckHostPatchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckHostPatchResponseMsg.typecode) - return response - - # op: CheckHostPatch_Task - def CheckHostPatch_Task(self, request): - if isinstance(request, CheckHostPatch_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckHostPatch_TaskResponseMsg.typecode) - return response - - # op: ScanHostPatch - def ScanHostPatch(self, request): - if isinstance(request, ScanHostPatchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ScanHostPatchResponseMsg.typecode) - return response - - # op: ScanHostPatch_Task - def ScanHostPatch_Task(self, request): - if isinstance(request, ScanHostPatch_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ScanHostPatch_TaskResponseMsg.typecode) - return response - - # op: ScanHostPatchV2 - def ScanHostPatchV2(self, request): - if isinstance(request, ScanHostPatchV2RequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ScanHostPatchV2ResponseMsg.typecode) - return response - - # op: ScanHostPatchV2_Task - def ScanHostPatchV2_Task(self, request): - if isinstance(request, ScanHostPatchV2_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ScanHostPatchV2_TaskResponseMsg.typecode) - return response - - # op: StageHostPatch - def StageHostPatch(self, request): - if isinstance(request, StageHostPatchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StageHostPatchResponseMsg.typecode) - return response - - # op: StageHostPatch_Task - def StageHostPatch_Task(self, request): - if isinstance(request, StageHostPatch_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StageHostPatch_TaskResponseMsg.typecode) - return response - - # op: InstallHostPatch - def InstallHostPatch(self, request): - if isinstance(request, InstallHostPatchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(InstallHostPatchResponseMsg.typecode) - return response - - # op: InstallHostPatch_Task - def InstallHostPatch_Task(self, request): - if isinstance(request, InstallHostPatch_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(InstallHostPatch_TaskResponseMsg.typecode) - return response - - # op: InstallHostPatchV2 - def InstallHostPatchV2(self, request): - if isinstance(request, InstallHostPatchV2RequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(InstallHostPatchV2ResponseMsg.typecode) - return response - - # op: InstallHostPatchV2_Task - def InstallHostPatchV2_Task(self, request): - if isinstance(request, InstallHostPatchV2_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(InstallHostPatchV2_TaskResponseMsg.typecode) - return response - - # op: UninstallHostPatch - def UninstallHostPatch(self, request): - if isinstance(request, UninstallHostPatchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UninstallHostPatchResponseMsg.typecode) - return response - - # op: UninstallHostPatch_Task - def UninstallHostPatch_Task(self, request): - if isinstance(request, UninstallHostPatch_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UninstallHostPatch_TaskResponseMsg.typecode) - return response - - # op: QueryHostPatch - def QueryHostPatch(self, request): - if isinstance(request, QueryHostPatchRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryHostPatchResponseMsg.typecode) - return response - - # op: QueryHostPatch_Task - def QueryHostPatch_Task(self, request): - if isinstance(request, QueryHostPatch_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryHostPatch_TaskResponseMsg.typecode) - return response - - # op: Refresh - def Refresh(self, request): - if isinstance(request, RefreshRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshResponseMsg.typecode) - return response - - # op: UpdatePassthruConfig - def UpdatePassthruConfig(self, request): - if isinstance(request, UpdatePassthruConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdatePassthruConfigResponseMsg.typecode) - return response - - # op: UpdateServicePolicy - def UpdateServicePolicy(self, request): - if isinstance(request, UpdateServicePolicyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateServicePolicyResponseMsg.typecode) - return response - - # op: StartService - def StartService(self, request): - if isinstance(request, StartServiceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StartServiceResponseMsg.typecode) - return response - - # op: StopService - def StopService(self, request): - if isinstance(request, StopServiceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(StopServiceResponseMsg.typecode) - return response - - # op: RestartService - def RestartService(self, request): - if isinstance(request, RestartServiceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RestartServiceResponseMsg.typecode) - return response - - # op: UninstallService - def UninstallService(self, request): - if isinstance(request, UninstallServiceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UninstallServiceResponseMsg.typecode) - return response - - # op: RefreshServices - def RefreshServices(self, request): - if isinstance(request, RefreshServicesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshServicesResponseMsg.typecode) - return response - - # op: ReconfigureSnmpAgent - def ReconfigureSnmpAgent(self, request): - if isinstance(request, ReconfigureSnmpAgentRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureSnmpAgentResponseMsg.typecode) - return response - - # op: SendTestNotification - def SendTestNotification(self, request): - if isinstance(request, SendTestNotificationRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SendTestNotificationResponseMsg.typecode) - return response - - # op: RetrieveDiskPartitionInfo - def RetrieveDiskPartitionInfo(self, request): - if isinstance(request, RetrieveDiskPartitionInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveDiskPartitionInfoResponseMsg.typecode) - return response - - # op: ComputeDiskPartitionInfo - def ComputeDiskPartitionInfo(self, request): - if isinstance(request, ComputeDiskPartitionInfoRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ComputeDiskPartitionInfoResponseMsg.typecode) - return response - - # op: ComputeDiskPartitionInfoForResize - def ComputeDiskPartitionInfoForResize(self, request): - if isinstance(request, ComputeDiskPartitionInfoForResizeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ComputeDiskPartitionInfoForResizeResponseMsg.typecode) - return response - - # op: UpdateDiskPartitions - def UpdateDiskPartitions(self, request): - if isinstance(request, UpdateDiskPartitionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateDiskPartitionsResponseMsg.typecode) - return response - - # op: FormatVmfs - def FormatVmfs(self, request): - if isinstance(request, FormatVmfsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(FormatVmfsResponseMsg.typecode) - return response - - # op: RescanVmfs - def RescanVmfs(self, request): - if isinstance(request, RescanVmfsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RescanVmfsResponseMsg.typecode) - return response - - # op: AttachVmfsExtent - def AttachVmfsExtent(self, request): - if isinstance(request, AttachVmfsExtentRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AttachVmfsExtentResponseMsg.typecode) - return response - - # op: ExpandVmfsExtent - def ExpandVmfsExtent(self, request): - if isinstance(request, ExpandVmfsExtentRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ExpandVmfsExtentResponseMsg.typecode) - return response - - # op: UpgradeVmfs - def UpgradeVmfs(self, request): - if isinstance(request, UpgradeVmfsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpgradeVmfsResponseMsg.typecode) - return response - - # op: UpgradeVmLayout - def UpgradeVmLayout(self, request): - if isinstance(request, UpgradeVmLayoutRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpgradeVmLayoutResponseMsg.typecode) - return response - - # op: QueryUnresolvedVmfsVolume - def QueryUnresolvedVmfsVolume(self, request): - if isinstance(request, QueryUnresolvedVmfsVolumeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryUnresolvedVmfsVolumeResponseMsg.typecode) - return response - - # op: ResolveMultipleUnresolvedVmfsVolumes - def ResolveMultipleUnresolvedVmfsVolumes(self, request): - if isinstance(request, ResolveMultipleUnresolvedVmfsVolumesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResolveMultipleUnresolvedVmfsVolumesResponseMsg.typecode) - return response - - # op: UnmountForceMountedVmfsVolume - def UnmountForceMountedVmfsVolume(self, request): - if isinstance(request, UnmountForceMountedVmfsVolumeRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UnmountForceMountedVmfsVolumeResponseMsg.typecode) - return response - - # op: RescanHba - def RescanHba(self, request): - if isinstance(request, RescanHbaRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RescanHbaResponseMsg.typecode) - return response - - # op: RescanAllHba - def RescanAllHba(self, request): - if isinstance(request, RescanAllHbaRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RescanAllHbaResponseMsg.typecode) - return response - - # op: UpdateSoftwareInternetScsiEnabled - def UpdateSoftwareInternetScsiEnabled(self, request): - if isinstance(request, UpdateSoftwareInternetScsiEnabledRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateSoftwareInternetScsiEnabledResponseMsg.typecode) - return response - - # op: UpdateInternetScsiDiscoveryProperties - def UpdateInternetScsiDiscoveryProperties(self, request): - if isinstance(request, UpdateInternetScsiDiscoveryPropertiesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateInternetScsiDiscoveryPropertiesResponseMsg.typecode) - return response - - # op: UpdateInternetScsiAuthenticationProperties - def UpdateInternetScsiAuthenticationProperties(self, request): - if isinstance(request, UpdateInternetScsiAuthenticationPropertiesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateInternetScsiAuthenticationPropertiesResponseMsg.typecode) - return response - - # op: UpdateInternetScsiDigestProperties - def UpdateInternetScsiDigestProperties(self, request): - if isinstance(request, UpdateInternetScsiDigestPropertiesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateInternetScsiDigestPropertiesResponseMsg.typecode) - return response - - # op: UpdateInternetScsiAdvancedOptions - def UpdateInternetScsiAdvancedOptions(self, request): - if isinstance(request, UpdateInternetScsiAdvancedOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateInternetScsiAdvancedOptionsResponseMsg.typecode) - return response - - # op: UpdateInternetScsiIPProperties - def UpdateInternetScsiIPProperties(self, request): - if isinstance(request, UpdateInternetScsiIPPropertiesRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateInternetScsiIPPropertiesResponseMsg.typecode) - return response - - # op: UpdateInternetScsiName - def UpdateInternetScsiName(self, request): - if isinstance(request, UpdateInternetScsiNameRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateInternetScsiNameResponseMsg.typecode) - return response - - # op: UpdateInternetScsiAlias - def UpdateInternetScsiAlias(self, request): - if isinstance(request, UpdateInternetScsiAliasRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateInternetScsiAliasResponseMsg.typecode) - return response - - # op: AddInternetScsiSendTargets - def AddInternetScsiSendTargets(self, request): - if isinstance(request, AddInternetScsiSendTargetsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddInternetScsiSendTargetsResponseMsg.typecode) - return response - - # op: RemoveInternetScsiSendTargets - def RemoveInternetScsiSendTargets(self, request): - if isinstance(request, RemoveInternetScsiSendTargetsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveInternetScsiSendTargetsResponseMsg.typecode) - return response - - # op: AddInternetScsiStaticTargets - def AddInternetScsiStaticTargets(self, request): - if isinstance(request, AddInternetScsiStaticTargetsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(AddInternetScsiStaticTargetsResponseMsg.typecode) - return response - - # op: RemoveInternetScsiStaticTargets - def RemoveInternetScsiStaticTargets(self, request): - if isinstance(request, RemoveInternetScsiStaticTargetsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveInternetScsiStaticTargetsResponseMsg.typecode) - return response - - # op: EnableMultipathPath - def EnableMultipathPath(self, request): - if isinstance(request, EnableMultipathPathRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(EnableMultipathPathResponseMsg.typecode) - return response - - # op: DisableMultipathPath - def DisableMultipathPath(self, request): - if isinstance(request, DisableMultipathPathRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DisableMultipathPathResponseMsg.typecode) - return response - - # op: SetMultipathLunPolicy - def SetMultipathLunPolicy(self, request): - if isinstance(request, SetMultipathLunPolicyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SetMultipathLunPolicyResponseMsg.typecode) - return response - - # op: QueryPathSelectionPolicyOptions - def QueryPathSelectionPolicyOptions(self, request): - if isinstance(request, QueryPathSelectionPolicyOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryPathSelectionPolicyOptionsResponseMsg.typecode) - return response - - # op: QueryStorageArrayTypePolicyOptions - def QueryStorageArrayTypePolicyOptions(self, request): - if isinstance(request, QueryStorageArrayTypePolicyOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryStorageArrayTypePolicyOptionsResponseMsg.typecode) - return response - - # op: UpdateScsiLunDisplayName - def UpdateScsiLunDisplayName(self, request): - if isinstance(request, UpdateScsiLunDisplayNameRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateScsiLunDisplayNameResponseMsg.typecode) - return response - - # op: RefreshStorageSystem - def RefreshStorageSystem(self, request): - if isinstance(request, RefreshStorageSystemRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RefreshStorageSystemResponseMsg.typecode) - return response - - # op: UpdateIpConfig - def UpdateIpConfig(self, request): - if isinstance(request, UpdateIpConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateIpConfigResponseMsg.typecode) - return response - - # op: SelectVnic - def SelectVnic(self, request): - if isinstance(request, SelectVnicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(SelectVnicResponseMsg.typecode) - return response - - # op: DeselectVnic - def DeselectVnic(self, request): - if isinstance(request, DeselectVnicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DeselectVnicResponseMsg.typecode) - return response - - # op: QueryNetConfig - def QueryNetConfig(self, request): - if isinstance(request, QueryNetConfigRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryNetConfigResponseMsg.typecode) - return response - - # op: VirtualNicManagerSelectVnic - def VirtualNicManagerSelectVnic(self, request): - if isinstance(request, VirtualNicManagerSelectVnicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(VirtualNicManagerSelectVnicResponseMsg.typecode) - return response - - # op: VirtualNicManagerDeselectVnic - def VirtualNicManagerDeselectVnic(self, request): - if isinstance(request, VirtualNicManagerDeselectVnicRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(VirtualNicManagerDeselectVnicResponseMsg.typecode) - return response - - # op: QueryOptions - def QueryOptions(self, request): - if isinstance(request, QueryOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryOptionsResponseMsg.typecode) - return response - - # op: UpdateOptions - def UpdateOptions(self, request): - if isinstance(request, UpdateOptionsRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(UpdateOptionsResponseMsg.typecode) - return response - - # op: ComplianceManagerCheckCompliance - def ComplianceManagerCheckCompliance(self, request): - if isinstance(request, ComplianceManagerCheckComplianceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ComplianceManagerCheckComplianceResponseMsg.typecode) - return response - - # op: ComplianceManagerCheckCompliance_Task - def ComplianceManagerCheckCompliance_Task(self, request): - if isinstance(request, ComplianceManagerCheckCompliance_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ComplianceManagerCheckCompliance_TaskResponseMsg.typecode) - return response - - # op: ComplianceManagerQueryComplianceStatus - def ComplianceManagerQueryComplianceStatus(self, request): - if isinstance(request, ComplianceManagerQueryComplianceStatusRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ComplianceManagerQueryComplianceStatusResponseMsg.typecode) - return response - - # op: ComplianceManagerClearComplianceStatus - def ComplianceManagerClearComplianceStatus(self, request): - if isinstance(request, ComplianceManagerClearComplianceStatusRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ComplianceManagerClearComplianceStatusResponseMsg.typecode) - return response - - # op: ComplianceManagerQueryExpressionMetadata - def ComplianceManagerQueryExpressionMetadata(self, request): - if isinstance(request, ComplianceManagerQueryExpressionMetadataRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ComplianceManagerQueryExpressionMetadataResponseMsg.typecode) - return response - - # op: ProfileDestroy - def ProfileDestroy(self, request): - if isinstance(request, ProfileDestroyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileDestroyResponseMsg.typecode) - return response - - # op: ProfileAssociate - def ProfileAssociate(self, request): - if isinstance(request, ProfileAssociateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileAssociateResponseMsg.typecode) - return response - - # op: ProfileDissociate - def ProfileDissociate(self, request): - if isinstance(request, ProfileDissociateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileDissociateResponseMsg.typecode) - return response - - # op: ProfileCheckCompliance - def ProfileCheckCompliance(self, request): - if isinstance(request, ProfileCheckComplianceRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileCheckComplianceResponseMsg.typecode) - return response - - # op: ProfileCheckCompliance_Task - def ProfileCheckCompliance_Task(self, request): - if isinstance(request, ProfileCheckCompliance_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileCheckCompliance_TaskResponseMsg.typecode) - return response - - # op: ProfileExportProfile - def ProfileExportProfile(self, request): - if isinstance(request, ProfileExportProfileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileExportProfileResponseMsg.typecode) - return response - - # op: CreateProfile - def CreateProfile(self, request): - if isinstance(request, CreateProfileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateProfileResponseMsg.typecode) - return response - - # op: ProfileQueryPolicyMetadata - def ProfileQueryPolicyMetadata(self, request): - if isinstance(request, ProfileQueryPolicyMetadataRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileQueryPolicyMetadataResponseMsg.typecode) - return response - - # op: ProfileFindAssociatedProfile - def ProfileFindAssociatedProfile(self, request): - if isinstance(request, ProfileFindAssociatedProfileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ProfileFindAssociatedProfileResponseMsg.typecode) - return response - - # op: ClusterProfileUpdate - def ClusterProfileUpdate(self, request): - if isinstance(request, ClusterProfileUpdateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ClusterProfileUpdateResponseMsg.typecode) - return response - - # op: HostProfileUpdateReferenceHost - def HostProfileUpdateReferenceHost(self, request): - if isinstance(request, HostProfileUpdateReferenceHostRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileUpdateReferenceHostResponseMsg.typecode) - return response - - # op: HostProfileUpdate - def HostProfileUpdate(self, request): - if isinstance(request, HostProfileUpdateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileUpdateResponseMsg.typecode) - return response - - # op: HostProfileExecute - def HostProfileExecute(self, request): - if isinstance(request, HostProfileExecuteRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileExecuteResponseMsg.typecode) - return response - - # op: HostProfileApply - def HostProfileApply(self, request): - if isinstance(request, HostProfileApplyRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileApplyResponseMsg.typecode) - return response - - # op: HostProfileApply_Task - def HostProfileApply_Task(self, request): - if isinstance(request, HostProfileApply_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileApply_TaskResponseMsg.typecode) - return response - - # op: HostProfileGenerateConfigTaskList - def HostProfileGenerateConfigTaskList(self, request): - if isinstance(request, HostProfileGenerateConfigTaskListRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileGenerateConfigTaskListResponseMsg.typecode) - return response - - # op: HostProfileQueryProfileMetadata - def HostProfileQueryProfileMetadata(self, request): - if isinstance(request, HostProfileQueryProfileMetadataRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileQueryProfileMetadataResponseMsg.typecode) - return response - - # op: HostProfileCreateDefaultProfile - def HostProfileCreateDefaultProfile(self, request): - if isinstance(request, HostProfileCreateDefaultProfileRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(HostProfileCreateDefaultProfileResponseMsg.typecode) - return response - - # op: RemoveScheduledTask - def RemoveScheduledTask(self, request): - if isinstance(request, RemoveScheduledTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveScheduledTaskResponseMsg.typecode) - return response - - # op: ReconfigureScheduledTask - def ReconfigureScheduledTask(self, request): - if isinstance(request, ReconfigureScheduledTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ReconfigureScheduledTaskResponseMsg.typecode) - return response - - # op: RunScheduledTask - def RunScheduledTask(self, request): - if isinstance(request, RunScheduledTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RunScheduledTaskResponseMsg.typecode) - return response - - # op: CreateScheduledTask - def CreateScheduledTask(self, request): - if isinstance(request, CreateScheduledTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateScheduledTaskResponseMsg.typecode) - return response - - # op: RetrieveEntityScheduledTask - def RetrieveEntityScheduledTask(self, request): - if isinstance(request, RetrieveEntityScheduledTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveEntityScheduledTaskResponseMsg.typecode) - return response - - # op: CreateObjectScheduledTask - def CreateObjectScheduledTask(self, request): - if isinstance(request, CreateObjectScheduledTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateObjectScheduledTaskResponseMsg.typecode) - return response - - # op: RetrieveObjectScheduledTask - def RetrieveObjectScheduledTask(self, request): - if isinstance(request, RetrieveObjectScheduledTaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RetrieveObjectScheduledTaskResponseMsg.typecode) - return response - - # op: OpenInventoryViewFolder - def OpenInventoryViewFolder(self, request): - if isinstance(request, OpenInventoryViewFolderRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(OpenInventoryViewFolderResponseMsg.typecode) - return response - - # op: CloseInventoryViewFolder - def CloseInventoryViewFolder(self, request): - if isinstance(request, CloseInventoryViewFolderRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CloseInventoryViewFolderResponseMsg.typecode) - return response - - # op: ModifyListView - def ModifyListView(self, request): - if isinstance(request, ModifyListViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ModifyListViewResponseMsg.typecode) - return response - - # op: ResetListView - def ResetListView(self, request): - if isinstance(request, ResetListViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetListViewResponseMsg.typecode) - return response - - # op: ResetListViewFromView - def ResetListViewFromView(self, request): - if isinstance(request, ResetListViewFromViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(ResetListViewFromViewResponseMsg.typecode) - return response - - # op: DestroyView - def DestroyView(self, request): - if isinstance(request, DestroyViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(DestroyViewResponseMsg.typecode) - return response - - # op: CreateInventoryView - def CreateInventoryView(self, request): - if isinstance(request, CreateInventoryViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateInventoryViewResponseMsg.typecode) - return response - - # op: CreateContainerView - def CreateContainerView(self, request): - if isinstance(request, CreateContainerViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateContainerViewResponseMsg.typecode) - return response - - # op: CreateListView - def CreateListView(self, request): - if isinstance(request, CreateListViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateListViewResponseMsg.typecode) - return response - - # op: CreateListViewFromView - def CreateListViewFromView(self, request): - if isinstance(request, CreateListViewFromViewRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CreateListViewFromViewResponseMsg.typecode) - return response - - # op: RevertToSnapshot - def RevertToSnapshot(self, request): - if isinstance(request, RevertToSnapshotRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RevertToSnapshotResponseMsg.typecode) - return response - - # op: RevertToSnapshot_Task - def RevertToSnapshot_Task(self, request): - if isinstance(request, RevertToSnapshot_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RevertToSnapshot_TaskResponseMsg.typecode) - return response - - # op: RemoveSnapshot - def RemoveSnapshot(self, request): - if isinstance(request, RemoveSnapshotRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveSnapshotResponseMsg.typecode) - return response - - # op: RemoveSnapshot_Task - def RemoveSnapshot_Task(self, request): - if isinstance(request, RemoveSnapshot_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RemoveSnapshot_TaskResponseMsg.typecode) - return response - - # op: RenameSnapshot - def RenameSnapshot(self, request): - if isinstance(request, RenameSnapshotRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(RenameSnapshotResponseMsg.typecode) - return response - - # op: CheckCompatibility - def CheckCompatibility(self, request): - if isinstance(request, CheckCompatibilityRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckCompatibilityResponseMsg.typecode) - return response - - # op: CheckCompatibility_Task - def CheckCompatibility_Task(self, request): - if isinstance(request, CheckCompatibility_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckCompatibility_TaskResponseMsg.typecode) - return response - - # op: QueryVMotionCompatibilityEx - def QueryVMotionCompatibilityEx(self, request): - if isinstance(request, QueryVMotionCompatibilityExRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVMotionCompatibilityExResponseMsg.typecode) - return response - - # op: QueryVMotionCompatibilityEx_Task - def QueryVMotionCompatibilityEx_Task(self, request): - if isinstance(request, QueryVMotionCompatibilityEx_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(QueryVMotionCompatibilityEx_TaskResponseMsg.typecode) - return response - - # op: CheckMigrate - def CheckMigrate(self, request): - if isinstance(request, CheckMigrateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckMigrateResponseMsg.typecode) - return response - - # op: CheckMigrate_Task - def CheckMigrate_Task(self, request): - if isinstance(request, CheckMigrate_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckMigrate_TaskResponseMsg.typecode) - return response - - # op: CheckRelocate - def CheckRelocate(self, request): - if isinstance(request, CheckRelocateRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckRelocateResponseMsg.typecode) - return response - - # op: CheckRelocate_Task - def CheckRelocate_Task(self, request): - if isinstance(request, CheckRelocate_TaskRequestMsg) is False: - raise TypeError, "%s incorrect request type" % (request.__class__) - kw = {} - # no input wsaction - self.binding.Send(None, None, request, soapaction="urn:vim25/4.0", **kw) - # no output wsaction - response = self.binding.Receive(CheckRelocate_TaskResponseMsg.typecode) - return response - -DestroyPropertyFilterRequestMsg = ns0.DestroyPropertyFilter_Dec().pyclass - -DestroyPropertyFilterResponseMsg = ns0.DestroyPropertyFilterResponse_Dec().pyclass - -CreateFilterRequestMsg = ns0.CreateFilter_Dec().pyclass - -CreateFilterResponseMsg = ns0.CreateFilterResponse_Dec().pyclass - -RetrievePropertiesRequestMsg = ns0.RetrieveProperties_Dec().pyclass - -RetrievePropertiesResponseMsg = ns0.RetrievePropertiesResponse_Dec().pyclass - -CheckForUpdatesRequestMsg = ns0.CheckForUpdates_Dec().pyclass - -CheckForUpdatesResponseMsg = ns0.CheckForUpdatesResponse_Dec().pyclass - -WaitForUpdatesRequestMsg = ns0.WaitForUpdates_Dec().pyclass - -WaitForUpdatesResponseMsg = ns0.WaitForUpdatesResponse_Dec().pyclass - -CancelWaitForUpdatesRequestMsg = ns0.CancelWaitForUpdates_Dec().pyclass - -CancelWaitForUpdatesResponseMsg = ns0.CancelWaitForUpdatesResponse_Dec().pyclass - -AddAuthorizationRoleRequestMsg = ns0.AddAuthorizationRole_Dec().pyclass - -AddAuthorizationRoleResponseMsg = ns0.AddAuthorizationRoleResponse_Dec().pyclass - -RemoveAuthorizationRoleRequestMsg = ns0.RemoveAuthorizationRole_Dec().pyclass - -RemoveAuthorizationRoleResponseMsg = ns0.RemoveAuthorizationRoleResponse_Dec().pyclass - -UpdateAuthorizationRoleRequestMsg = ns0.UpdateAuthorizationRole_Dec().pyclass - -UpdateAuthorizationRoleResponseMsg = ns0.UpdateAuthorizationRoleResponse_Dec().pyclass - -MergePermissionsRequestMsg = ns0.MergePermissions_Dec().pyclass - -MergePermissionsResponseMsg = ns0.MergePermissionsResponse_Dec().pyclass - -RetrieveRolePermissionsRequestMsg = ns0.RetrieveRolePermissions_Dec().pyclass - -RetrieveRolePermissionsResponseMsg = ns0.RetrieveRolePermissionsResponse_Dec().pyclass - -RetrieveEntityPermissionsRequestMsg = ns0.RetrieveEntityPermissions_Dec().pyclass - -RetrieveEntityPermissionsResponseMsg = ns0.RetrieveEntityPermissionsResponse_Dec().pyclass - -RetrieveAllPermissionsRequestMsg = ns0.RetrieveAllPermissions_Dec().pyclass - -RetrieveAllPermissionsResponseMsg = ns0.RetrieveAllPermissionsResponse_Dec().pyclass - -SetEntityPermissionsRequestMsg = ns0.SetEntityPermissions_Dec().pyclass - -SetEntityPermissionsResponseMsg = ns0.SetEntityPermissionsResponse_Dec().pyclass - -ResetEntityPermissionsRequestMsg = ns0.ResetEntityPermissions_Dec().pyclass - -ResetEntityPermissionsResponseMsg = ns0.ResetEntityPermissionsResponse_Dec().pyclass - -RemoveEntityPermissionRequestMsg = ns0.RemoveEntityPermission_Dec().pyclass - -RemoveEntityPermissionResponseMsg = ns0.RemoveEntityPermissionResponse_Dec().pyclass - -ReconfigureClusterRequestMsg = ns0.ReconfigureCluster_Dec().pyclass - -ReconfigureClusterResponseMsg = ns0.ReconfigureClusterResponse_Dec().pyclass - -ReconfigureCluster_TaskRequestMsg = ns0.ReconfigureCluster_Task_Dec().pyclass - -ReconfigureCluster_TaskResponseMsg = ns0.ReconfigureCluster_TaskResponse_Dec().pyclass - -ApplyRecommendationRequestMsg = ns0.ApplyRecommendation_Dec().pyclass - -ApplyRecommendationResponseMsg = ns0.ApplyRecommendationResponse_Dec().pyclass - -RecommendHostsForVmRequestMsg = ns0.RecommendHostsForVm_Dec().pyclass - -RecommendHostsForVmResponseMsg = ns0.RecommendHostsForVmResponse_Dec().pyclass - -AddHostRequestMsg = ns0.AddHost_Dec().pyclass - -AddHostResponseMsg = ns0.AddHostResponse_Dec().pyclass - -AddHost_TaskRequestMsg = ns0.AddHost_Task_Dec().pyclass - -AddHost_TaskResponseMsg = ns0.AddHost_TaskResponse_Dec().pyclass - -MoveIntoRequestMsg = ns0.MoveInto_Dec().pyclass - -MoveIntoResponseMsg = ns0.MoveIntoResponse_Dec().pyclass - -MoveInto_TaskRequestMsg = ns0.MoveInto_Task_Dec().pyclass - -MoveInto_TaskResponseMsg = ns0.MoveInto_TaskResponse_Dec().pyclass - -MoveHostIntoRequestMsg = ns0.MoveHostInto_Dec().pyclass - -MoveHostIntoResponseMsg = ns0.MoveHostIntoResponse_Dec().pyclass - -MoveHostInto_TaskRequestMsg = ns0.MoveHostInto_Task_Dec().pyclass - -MoveHostInto_TaskResponseMsg = ns0.MoveHostInto_TaskResponse_Dec().pyclass - -RefreshRecommendationRequestMsg = ns0.RefreshRecommendation_Dec().pyclass - -RefreshRecommendationResponseMsg = ns0.RefreshRecommendationResponse_Dec().pyclass - -RetrieveDasAdvancedRuntimeInfoRequestMsg = ns0.RetrieveDasAdvancedRuntimeInfo_Dec().pyclass - -RetrieveDasAdvancedRuntimeInfoResponseMsg = ns0.RetrieveDasAdvancedRuntimeInfoResponse_Dec().pyclass - -ReconfigureComputeResourceRequestMsg = ns0.ReconfigureComputeResource_Dec().pyclass - -ReconfigureComputeResourceResponseMsg = ns0.ReconfigureComputeResourceResponse_Dec().pyclass - -ReconfigureComputeResource_TaskRequestMsg = ns0.ReconfigureComputeResource_Task_Dec().pyclass - -ReconfigureComputeResource_TaskResponseMsg = ns0.ReconfigureComputeResource_TaskResponse_Dec().pyclass - -AddCustomFieldDefRequestMsg = ns0.AddCustomFieldDef_Dec().pyclass - -AddCustomFieldDefResponseMsg = ns0.AddCustomFieldDefResponse_Dec().pyclass - -RemoveCustomFieldDefRequestMsg = ns0.RemoveCustomFieldDef_Dec().pyclass - -RemoveCustomFieldDefResponseMsg = ns0.RemoveCustomFieldDefResponse_Dec().pyclass - -RenameCustomFieldDefRequestMsg = ns0.RenameCustomFieldDef_Dec().pyclass - -RenameCustomFieldDefResponseMsg = ns0.RenameCustomFieldDefResponse_Dec().pyclass - -SetFieldRequestMsg = ns0.SetField_Dec().pyclass - -SetFieldResponseMsg = ns0.SetFieldResponse_Dec().pyclass - -DoesCustomizationSpecExistRequestMsg = ns0.DoesCustomizationSpecExist_Dec().pyclass - -DoesCustomizationSpecExistResponseMsg = ns0.DoesCustomizationSpecExistResponse_Dec().pyclass - -GetCustomizationSpecRequestMsg = ns0.GetCustomizationSpec_Dec().pyclass - -GetCustomizationSpecResponseMsg = ns0.GetCustomizationSpecResponse_Dec().pyclass - -CreateCustomizationSpecRequestMsg = ns0.CreateCustomizationSpec_Dec().pyclass - -CreateCustomizationSpecResponseMsg = ns0.CreateCustomizationSpecResponse_Dec().pyclass - -OverwriteCustomizationSpecRequestMsg = ns0.OverwriteCustomizationSpec_Dec().pyclass - -OverwriteCustomizationSpecResponseMsg = ns0.OverwriteCustomizationSpecResponse_Dec().pyclass - -DeleteCustomizationSpecRequestMsg = ns0.DeleteCustomizationSpec_Dec().pyclass - -DeleteCustomizationSpecResponseMsg = ns0.DeleteCustomizationSpecResponse_Dec().pyclass - -DuplicateCustomizationSpecRequestMsg = ns0.DuplicateCustomizationSpec_Dec().pyclass - -DuplicateCustomizationSpecResponseMsg = ns0.DuplicateCustomizationSpecResponse_Dec().pyclass - -RenameCustomizationSpecRequestMsg = ns0.RenameCustomizationSpec_Dec().pyclass - -RenameCustomizationSpecResponseMsg = ns0.RenameCustomizationSpecResponse_Dec().pyclass - -CustomizationSpecItemToXmlRequestMsg = ns0.CustomizationSpecItemToXml_Dec().pyclass - -CustomizationSpecItemToXmlResponseMsg = ns0.CustomizationSpecItemToXmlResponse_Dec().pyclass - -XmlToCustomizationSpecItemRequestMsg = ns0.XmlToCustomizationSpecItem_Dec().pyclass - -XmlToCustomizationSpecItemResponseMsg = ns0.XmlToCustomizationSpecItemResponse_Dec().pyclass - -CheckCustomizationResourcesRequestMsg = ns0.CheckCustomizationResources_Dec().pyclass - -CheckCustomizationResourcesResponseMsg = ns0.CheckCustomizationResourcesResponse_Dec().pyclass - -QueryConnectionInfoRequestMsg = ns0.QueryConnectionInfo_Dec().pyclass - -QueryConnectionInfoResponseMsg = ns0.QueryConnectionInfoResponse_Dec().pyclass - -PowerOnMultiVMRequestMsg = ns0.PowerOnMultiVM_Dec().pyclass - -PowerOnMultiVMResponseMsg = ns0.PowerOnMultiVMResponse_Dec().pyclass - -PowerOnMultiVM_TaskRequestMsg = ns0.PowerOnMultiVM_Task_Dec().pyclass - -PowerOnMultiVM_TaskResponseMsg = ns0.PowerOnMultiVM_TaskResponse_Dec().pyclass - -RefreshDatastoreRequestMsg = ns0.RefreshDatastore_Dec().pyclass - -RefreshDatastoreResponseMsg = ns0.RefreshDatastoreResponse_Dec().pyclass - -RefreshDatastoreStorageInfoRequestMsg = ns0.RefreshDatastoreStorageInfo_Dec().pyclass - -RefreshDatastoreStorageInfoResponseMsg = ns0.RefreshDatastoreStorageInfoResponse_Dec().pyclass - -RenameDatastoreRequestMsg = ns0.RenameDatastore_Dec().pyclass - -RenameDatastoreResponseMsg = ns0.RenameDatastoreResponse_Dec().pyclass - -DestroyDatastoreRequestMsg = ns0.DestroyDatastore_Dec().pyclass - -DestroyDatastoreResponseMsg = ns0.DestroyDatastoreResponse_Dec().pyclass - -QueryDescriptionsRequestMsg = ns0.QueryDescriptions_Dec().pyclass - -QueryDescriptionsResponseMsg = ns0.QueryDescriptionsResponse_Dec().pyclass - -BrowseDiagnosticLogRequestMsg = ns0.BrowseDiagnosticLog_Dec().pyclass - -BrowseDiagnosticLogResponseMsg = ns0.BrowseDiagnosticLogResponse_Dec().pyclass - -GenerateLogBundlesRequestMsg = ns0.GenerateLogBundles_Dec().pyclass - -GenerateLogBundlesResponseMsg = ns0.GenerateLogBundlesResponse_Dec().pyclass - -GenerateLogBundles_TaskRequestMsg = ns0.GenerateLogBundles_Task_Dec().pyclass - -GenerateLogBundles_TaskResponseMsg = ns0.GenerateLogBundles_TaskResponse_Dec().pyclass - -DVSFetchKeyOfPortsRequestMsg = ns0.DVSFetchKeyOfPorts_Dec().pyclass - -DVSFetchKeyOfPortsResponseMsg = ns0.DVSFetchKeyOfPortsResponse_Dec().pyclass - -DVSFetchPortsRequestMsg = ns0.DVSFetchPorts_Dec().pyclass - -DVSFetchPortsResponseMsg = ns0.DVSFetchPortsResponse_Dec().pyclass - -DVSQueryUsedVlanIdRequestMsg = ns0.DVSQueryUsedVlanId_Dec().pyclass - -DVSQueryUsedVlanIdResponseMsg = ns0.DVSQueryUsedVlanIdResponse_Dec().pyclass - -DVSReconfigureRequestMsg = ns0.DVSReconfigure_Dec().pyclass - -DVSReconfigureResponseMsg = ns0.DVSReconfigureResponse_Dec().pyclass - -DVSReconfigure_TaskRequestMsg = ns0.DVSReconfigure_Task_Dec().pyclass - -DVSReconfigure_TaskResponseMsg = ns0.DVSReconfigure_TaskResponse_Dec().pyclass - -DVSPerformProductSpecOperationRequestMsg = ns0.DVSPerformProductSpecOperation_Dec().pyclass - -DVSPerformProductSpecOperationResponseMsg = ns0.DVSPerformProductSpecOperationResponse_Dec().pyclass - -DVSPerformProductSpecOperation_TaskRequestMsg = ns0.DVSPerformProductSpecOperation_Task_Dec().pyclass - -DVSPerformProductSpecOperation_TaskResponseMsg = ns0.DVSPerformProductSpecOperation_TaskResponse_Dec().pyclass - -DVSMergeRequestMsg = ns0.DVSMerge_Dec().pyclass - -DVSMergeResponseMsg = ns0.DVSMergeResponse_Dec().pyclass - -DVSMerge_TaskRequestMsg = ns0.DVSMerge_Task_Dec().pyclass - -DVSMerge_TaskResponseMsg = ns0.DVSMerge_TaskResponse_Dec().pyclass - -DVSAddPortgroupsRequestMsg = ns0.DVSAddPortgroups_Dec().pyclass - -DVSAddPortgroupsResponseMsg = ns0.DVSAddPortgroupsResponse_Dec().pyclass - -DVSMovePortRequestMsg = ns0.DVSMovePort_Dec().pyclass - -DVSMovePortResponseMsg = ns0.DVSMovePortResponse_Dec().pyclass - -DVSUpdateCapabilityRequestMsg = ns0.DVSUpdateCapability_Dec().pyclass - -DVSUpdateCapabilityResponseMsg = ns0.DVSUpdateCapabilityResponse_Dec().pyclass - -ReconfigurePortRequestMsg = ns0.ReconfigurePort_Dec().pyclass - -ReconfigurePortResponseMsg = ns0.ReconfigurePortResponse_Dec().pyclass - -DVSRefreshPortStateRequestMsg = ns0.DVSRefreshPortState_Dec().pyclass - -DVSRefreshPortStateResponseMsg = ns0.DVSRefreshPortStateResponse_Dec().pyclass - -DVSRectifyHostRequestMsg = ns0.DVSRectifyHost_Dec().pyclass - -DVSRectifyHostResponseMsg = ns0.DVSRectifyHostResponse_Dec().pyclass - -QueryConfigOptionDescriptorRequestMsg = ns0.QueryConfigOptionDescriptor_Dec().pyclass - -QueryConfigOptionDescriptorResponseMsg = ns0.QueryConfigOptionDescriptorResponse_Dec().pyclass - -QueryConfigOptionRequestMsg = ns0.QueryConfigOption_Dec().pyclass - -QueryConfigOptionResponseMsg = ns0.QueryConfigOptionResponse_Dec().pyclass - -QueryConfigTargetRequestMsg = ns0.QueryConfigTarget_Dec().pyclass - -QueryConfigTargetResponseMsg = ns0.QueryConfigTargetResponse_Dec().pyclass - -QueryTargetCapabilitiesRequestMsg = ns0.QueryTargetCapabilities_Dec().pyclass - -QueryTargetCapabilitiesResponseMsg = ns0.QueryTargetCapabilitiesResponse_Dec().pyclass - -setCustomValueRequestMsg = ns0.setCustomValue_Dec().pyclass - -setCustomValueResponseMsg = ns0.setCustomValueResponse_Dec().pyclass - -UnregisterExtensionRequestMsg = ns0.UnregisterExtension_Dec().pyclass - -UnregisterExtensionResponseMsg = ns0.UnregisterExtensionResponse_Dec().pyclass - -FindExtensionRequestMsg = ns0.FindExtension_Dec().pyclass - -FindExtensionResponseMsg = ns0.FindExtensionResponse_Dec().pyclass - -RegisterExtensionRequestMsg = ns0.RegisterExtension_Dec().pyclass - -RegisterExtensionResponseMsg = ns0.RegisterExtensionResponse_Dec().pyclass - -UpdateExtensionRequestMsg = ns0.UpdateExtension_Dec().pyclass - -UpdateExtensionResponseMsg = ns0.UpdateExtensionResponse_Dec().pyclass - -GetPublicKeyRequestMsg = ns0.GetPublicKey_Dec().pyclass - -GetPublicKeyResponseMsg = ns0.GetPublicKeyResponse_Dec().pyclass - -SetPublicKeyRequestMsg = ns0.SetPublicKey_Dec().pyclass - -SetPublicKeyResponseMsg = ns0.SetPublicKeyResponse_Dec().pyclass - -MoveDatastoreFileRequestMsg = ns0.MoveDatastoreFile_Dec().pyclass - -MoveDatastoreFileResponseMsg = ns0.MoveDatastoreFileResponse_Dec().pyclass - -MoveDatastoreFile_TaskRequestMsg = ns0.MoveDatastoreFile_Task_Dec().pyclass - -MoveDatastoreFile_TaskResponseMsg = ns0.MoveDatastoreFile_TaskResponse_Dec().pyclass - -CopyDatastoreFileRequestMsg = ns0.CopyDatastoreFile_Dec().pyclass - -CopyDatastoreFileResponseMsg = ns0.CopyDatastoreFileResponse_Dec().pyclass - -CopyDatastoreFile_TaskRequestMsg = ns0.CopyDatastoreFile_Task_Dec().pyclass - -CopyDatastoreFile_TaskResponseMsg = ns0.CopyDatastoreFile_TaskResponse_Dec().pyclass - -DeleteDatastoreFileRequestMsg = ns0.DeleteDatastoreFile_Dec().pyclass - -DeleteDatastoreFileResponseMsg = ns0.DeleteDatastoreFileResponse_Dec().pyclass - -DeleteDatastoreFile_TaskRequestMsg = ns0.DeleteDatastoreFile_Task_Dec().pyclass - -DeleteDatastoreFile_TaskResponseMsg = ns0.DeleteDatastoreFile_TaskResponse_Dec().pyclass - -MakeDirectoryRequestMsg = ns0.MakeDirectory_Dec().pyclass - -MakeDirectoryResponseMsg = ns0.MakeDirectoryResponse_Dec().pyclass - -ChangeOwnerRequestMsg = ns0.ChangeOwner_Dec().pyclass - -ChangeOwnerResponseMsg = ns0.ChangeOwnerResponse_Dec().pyclass - -CreateFolderRequestMsg = ns0.CreateFolder_Dec().pyclass - -CreateFolderResponseMsg = ns0.CreateFolderResponse_Dec().pyclass - -MoveIntoFolderRequestMsg = ns0.MoveIntoFolder_Dec().pyclass - -MoveIntoFolderResponseMsg = ns0.MoveIntoFolderResponse_Dec().pyclass - -MoveIntoFolder_TaskRequestMsg = ns0.MoveIntoFolder_Task_Dec().pyclass - -MoveIntoFolder_TaskResponseMsg = ns0.MoveIntoFolder_TaskResponse_Dec().pyclass - -CreateVMRequestMsg = ns0.CreateVM_Dec().pyclass - -CreateVMResponseMsg = ns0.CreateVMResponse_Dec().pyclass - -CreateVM_TaskRequestMsg = ns0.CreateVM_Task_Dec().pyclass - -CreateVM_TaskResponseMsg = ns0.CreateVM_TaskResponse_Dec().pyclass - -RegisterVMRequestMsg = ns0.RegisterVM_Dec().pyclass - -RegisterVMResponseMsg = ns0.RegisterVMResponse_Dec().pyclass - -RegisterVM_TaskRequestMsg = ns0.RegisterVM_Task_Dec().pyclass - -RegisterVM_TaskResponseMsg = ns0.RegisterVM_TaskResponse_Dec().pyclass - -CreateClusterRequestMsg = ns0.CreateCluster_Dec().pyclass - -CreateClusterResponseMsg = ns0.CreateClusterResponse_Dec().pyclass - -CreateClusterExRequestMsg = ns0.CreateClusterEx_Dec().pyclass - -CreateClusterExResponseMsg = ns0.CreateClusterExResponse_Dec().pyclass - -AddStandaloneHostRequestMsg = ns0.AddStandaloneHost_Dec().pyclass - -AddStandaloneHostResponseMsg = ns0.AddStandaloneHostResponse_Dec().pyclass - -AddStandaloneHost_TaskRequestMsg = ns0.AddStandaloneHost_Task_Dec().pyclass - -AddStandaloneHost_TaskResponseMsg = ns0.AddStandaloneHost_TaskResponse_Dec().pyclass - -CreateDatacenterRequestMsg = ns0.CreateDatacenter_Dec().pyclass - -CreateDatacenterResponseMsg = ns0.CreateDatacenterResponse_Dec().pyclass - -UnregisterAndDestroyRequestMsg = ns0.UnregisterAndDestroy_Dec().pyclass - -UnregisterAndDestroyResponseMsg = ns0.UnregisterAndDestroyResponse_Dec().pyclass - -UnregisterAndDestroy_TaskRequestMsg = ns0.UnregisterAndDestroy_Task_Dec().pyclass - -UnregisterAndDestroy_TaskResponseMsg = ns0.UnregisterAndDestroy_TaskResponse_Dec().pyclass - -FolderCreateDVSRequestMsg = ns0.FolderCreateDVS_Dec().pyclass - -FolderCreateDVSResponseMsg = ns0.FolderCreateDVSResponse_Dec().pyclass - -SetCollectorPageSizeRequestMsg = ns0.SetCollectorPageSize_Dec().pyclass - -SetCollectorPageSizeResponseMsg = ns0.SetCollectorPageSizeResponse_Dec().pyclass - -RewindCollectorRequestMsg = ns0.RewindCollector_Dec().pyclass - -RewindCollectorResponseMsg = ns0.RewindCollectorResponse_Dec().pyclass - -ResetCollectorRequestMsg = ns0.ResetCollector_Dec().pyclass - -ResetCollectorResponseMsg = ns0.ResetCollectorResponse_Dec().pyclass - -DestroyCollectorRequestMsg = ns0.DestroyCollector_Dec().pyclass - -DestroyCollectorResponseMsg = ns0.DestroyCollectorResponse_Dec().pyclass - -QueryHostConnectionInfoRequestMsg = ns0.QueryHostConnectionInfo_Dec().pyclass - -QueryHostConnectionInfoResponseMsg = ns0.QueryHostConnectionInfoResponse_Dec().pyclass - -UpdateSystemResourcesRequestMsg = ns0.UpdateSystemResources_Dec().pyclass - -UpdateSystemResourcesResponseMsg = ns0.UpdateSystemResourcesResponse_Dec().pyclass - -ReconnectHostRequestMsg = ns0.ReconnectHost_Dec().pyclass - -ReconnectHostResponseMsg = ns0.ReconnectHostResponse_Dec().pyclass - -ReconnectHost_TaskRequestMsg = ns0.ReconnectHost_Task_Dec().pyclass - -ReconnectHost_TaskResponseMsg = ns0.ReconnectHost_TaskResponse_Dec().pyclass - -DisconnectHostRequestMsg = ns0.DisconnectHost_Dec().pyclass - -DisconnectHostResponseMsg = ns0.DisconnectHostResponse_Dec().pyclass - -DisconnectHost_TaskRequestMsg = ns0.DisconnectHost_Task_Dec().pyclass - -DisconnectHost_TaskResponseMsg = ns0.DisconnectHost_TaskResponse_Dec().pyclass - -EnterMaintenanceModeRequestMsg = ns0.EnterMaintenanceMode_Dec().pyclass - -EnterMaintenanceModeResponseMsg = ns0.EnterMaintenanceModeResponse_Dec().pyclass - -EnterMaintenanceMode_TaskRequestMsg = ns0.EnterMaintenanceMode_Task_Dec().pyclass - -EnterMaintenanceMode_TaskResponseMsg = ns0.EnterMaintenanceMode_TaskResponse_Dec().pyclass - -ExitMaintenanceModeRequestMsg = ns0.ExitMaintenanceMode_Dec().pyclass - -ExitMaintenanceModeResponseMsg = ns0.ExitMaintenanceModeResponse_Dec().pyclass - -ExitMaintenanceMode_TaskRequestMsg = ns0.ExitMaintenanceMode_Task_Dec().pyclass - -ExitMaintenanceMode_TaskResponseMsg = ns0.ExitMaintenanceMode_TaskResponse_Dec().pyclass - -RebootHostRequestMsg = ns0.RebootHost_Dec().pyclass - -RebootHostResponseMsg = ns0.RebootHostResponse_Dec().pyclass - -RebootHost_TaskRequestMsg = ns0.RebootHost_Task_Dec().pyclass - -RebootHost_TaskResponseMsg = ns0.RebootHost_TaskResponse_Dec().pyclass - -ShutdownHostRequestMsg = ns0.ShutdownHost_Dec().pyclass - -ShutdownHostResponseMsg = ns0.ShutdownHostResponse_Dec().pyclass - -ShutdownHost_TaskRequestMsg = ns0.ShutdownHost_Task_Dec().pyclass - -ShutdownHost_TaskResponseMsg = ns0.ShutdownHost_TaskResponse_Dec().pyclass - -PowerDownHostToStandByRequestMsg = ns0.PowerDownHostToStandBy_Dec().pyclass - -PowerDownHostToStandByResponseMsg = ns0.PowerDownHostToStandByResponse_Dec().pyclass - -PowerDownHostToStandBy_TaskRequestMsg = ns0.PowerDownHostToStandBy_Task_Dec().pyclass - -PowerDownHostToStandBy_TaskResponseMsg = ns0.PowerDownHostToStandBy_TaskResponse_Dec().pyclass - -PowerUpHostFromStandByRequestMsg = ns0.PowerUpHostFromStandBy_Dec().pyclass - -PowerUpHostFromStandByResponseMsg = ns0.PowerUpHostFromStandByResponse_Dec().pyclass - -PowerUpHostFromStandBy_TaskRequestMsg = ns0.PowerUpHostFromStandBy_Task_Dec().pyclass - -PowerUpHostFromStandBy_TaskResponseMsg = ns0.PowerUpHostFromStandBy_TaskResponse_Dec().pyclass - -QueryMemoryOverheadRequestMsg = ns0.QueryMemoryOverhead_Dec().pyclass - -QueryMemoryOverheadResponseMsg = ns0.QueryMemoryOverheadResponse_Dec().pyclass - -QueryMemoryOverheadExRequestMsg = ns0.QueryMemoryOverheadEx_Dec().pyclass - -QueryMemoryOverheadExResponseMsg = ns0.QueryMemoryOverheadExResponse_Dec().pyclass - -ReconfigureHostForDASRequestMsg = ns0.ReconfigureHostForDAS_Dec().pyclass - -ReconfigureHostForDASResponseMsg = ns0.ReconfigureHostForDASResponse_Dec().pyclass - -ReconfigureHostForDAS_TaskRequestMsg = ns0.ReconfigureHostForDAS_Task_Dec().pyclass - -ReconfigureHostForDAS_TaskResponseMsg = ns0.ReconfigureHostForDAS_TaskResponse_Dec().pyclass - -UpdateFlagsRequestMsg = ns0.UpdateFlags_Dec().pyclass - -UpdateFlagsResponseMsg = ns0.UpdateFlagsResponse_Dec().pyclass - -AcquireCimServicesTicketRequestMsg = ns0.AcquireCimServicesTicket_Dec().pyclass - -AcquireCimServicesTicketResponseMsg = ns0.AcquireCimServicesTicketResponse_Dec().pyclass - -UpdateIpmiRequestMsg = ns0.UpdateIpmi_Dec().pyclass - -UpdateIpmiResponseMsg = ns0.UpdateIpmiResponse_Dec().pyclass - -HttpNfcLeaseCompleteRequestMsg = ns0.HttpNfcLeaseComplete_Dec().pyclass - -HttpNfcLeaseCompleteResponseMsg = ns0.HttpNfcLeaseCompleteResponse_Dec().pyclass - -HttpNfcLeaseAbortRequestMsg = ns0.HttpNfcLeaseAbort_Dec().pyclass - -HttpNfcLeaseAbortResponseMsg = ns0.HttpNfcLeaseAbortResponse_Dec().pyclass - -HttpNfcLeaseProgressRequestMsg = ns0.HttpNfcLeaseProgress_Dec().pyclass - -HttpNfcLeaseProgressResponseMsg = ns0.HttpNfcLeaseProgressResponse_Dec().pyclass - -QueryIpPoolsRequestMsg = ns0.QueryIpPools_Dec().pyclass - -QueryIpPoolsResponseMsg = ns0.QueryIpPoolsResponse_Dec().pyclass - -CreateIpPoolRequestMsg = ns0.CreateIpPool_Dec().pyclass - -CreateIpPoolResponseMsg = ns0.CreateIpPoolResponse_Dec().pyclass - -UpdateIpPoolRequestMsg = ns0.UpdateIpPool_Dec().pyclass - -UpdateIpPoolResponseMsg = ns0.UpdateIpPoolResponse_Dec().pyclass - -DestroyIpPoolRequestMsg = ns0.DestroyIpPool_Dec().pyclass - -DestroyIpPoolResponseMsg = ns0.DestroyIpPoolResponse_Dec().pyclass - -AssociateIpPoolRequestMsg = ns0.AssociateIpPool_Dec().pyclass - -AssociateIpPoolResponseMsg = ns0.AssociateIpPoolResponse_Dec().pyclass - -UpdateAssignedLicenseRequestMsg = ns0.UpdateAssignedLicense_Dec().pyclass - -UpdateAssignedLicenseResponseMsg = ns0.UpdateAssignedLicenseResponse_Dec().pyclass - -RemoveAssignedLicenseRequestMsg = ns0.RemoveAssignedLicense_Dec().pyclass - -RemoveAssignedLicenseResponseMsg = ns0.RemoveAssignedLicenseResponse_Dec().pyclass - -QueryAssignedLicensesRequestMsg = ns0.QueryAssignedLicenses_Dec().pyclass - -QueryAssignedLicensesResponseMsg = ns0.QueryAssignedLicensesResponse_Dec().pyclass - -IsFeatureAvailableRequestMsg = ns0.IsFeatureAvailable_Dec().pyclass - -IsFeatureAvailableResponseMsg = ns0.IsFeatureAvailableResponse_Dec().pyclass - -SetFeatureInUseRequestMsg = ns0.SetFeatureInUse_Dec().pyclass - -SetFeatureInUseResponseMsg = ns0.SetFeatureInUseResponse_Dec().pyclass - -ResetFeatureInUseRequestMsg = ns0.ResetFeatureInUse_Dec().pyclass - -ResetFeatureInUseResponseMsg = ns0.ResetFeatureInUseResponse_Dec().pyclass - -QuerySupportedFeaturesRequestMsg = ns0.QuerySupportedFeatures_Dec().pyclass - -QuerySupportedFeaturesResponseMsg = ns0.QuerySupportedFeaturesResponse_Dec().pyclass - -QueryLicenseSourceAvailabilityRequestMsg = ns0.QueryLicenseSourceAvailability_Dec().pyclass - -QueryLicenseSourceAvailabilityResponseMsg = ns0.QueryLicenseSourceAvailabilityResponse_Dec().pyclass - -QueryLicenseUsageRequestMsg = ns0.QueryLicenseUsage_Dec().pyclass - -QueryLicenseUsageResponseMsg = ns0.QueryLicenseUsageResponse_Dec().pyclass - -SetLicenseEditionRequestMsg = ns0.SetLicenseEdition_Dec().pyclass - -SetLicenseEditionResponseMsg = ns0.SetLicenseEditionResponse_Dec().pyclass - -CheckLicenseFeatureRequestMsg = ns0.CheckLicenseFeature_Dec().pyclass - -CheckLicenseFeatureResponseMsg = ns0.CheckLicenseFeatureResponse_Dec().pyclass - -EnableFeatureRequestMsg = ns0.EnableFeature_Dec().pyclass - -EnableFeatureResponseMsg = ns0.EnableFeatureResponse_Dec().pyclass - -DisableFeatureRequestMsg = ns0.DisableFeature_Dec().pyclass - -DisableFeatureResponseMsg = ns0.DisableFeatureResponse_Dec().pyclass - -ConfigureLicenseSourceRequestMsg = ns0.ConfigureLicenseSource_Dec().pyclass - -ConfigureLicenseSourceResponseMsg = ns0.ConfigureLicenseSourceResponse_Dec().pyclass - -UpdateLicenseRequestMsg = ns0.UpdateLicense_Dec().pyclass - -UpdateLicenseResponseMsg = ns0.UpdateLicenseResponse_Dec().pyclass - -AddLicenseRequestMsg = ns0.AddLicense_Dec().pyclass - -AddLicenseResponseMsg = ns0.AddLicenseResponse_Dec().pyclass - -RemoveLicenseRequestMsg = ns0.RemoveLicense_Dec().pyclass - -RemoveLicenseResponseMsg = ns0.RemoveLicenseResponse_Dec().pyclass - -DecodeLicenseRequestMsg = ns0.DecodeLicense_Dec().pyclass - -DecodeLicenseResponseMsg = ns0.DecodeLicenseResponse_Dec().pyclass - -UpdateLicenseLabelRequestMsg = ns0.UpdateLicenseLabel_Dec().pyclass - -UpdateLicenseLabelResponseMsg = ns0.UpdateLicenseLabelResponse_Dec().pyclass - -RemoveLicenseLabelRequestMsg = ns0.RemoveLicenseLabel_Dec().pyclass - -RemoveLicenseLabelResponseMsg = ns0.RemoveLicenseLabelResponse_Dec().pyclass - -ReloadRequestMsg = ns0.Reload_Dec().pyclass - -ReloadResponseMsg = ns0.ReloadResponse_Dec().pyclass - -RenameRequestMsg = ns0.Rename_Dec().pyclass - -RenameResponseMsg = ns0.RenameResponse_Dec().pyclass - -Rename_TaskRequestMsg = ns0.Rename_Task_Dec().pyclass - -Rename_TaskResponseMsg = ns0.Rename_TaskResponse_Dec().pyclass - -DestroyRequestMsg = ns0.Destroy_Dec().pyclass - -DestroyResponseMsg = ns0.DestroyResponse_Dec().pyclass - -Destroy_TaskRequestMsg = ns0.Destroy_Task_Dec().pyclass - -Destroy_TaskResponseMsg = ns0.Destroy_TaskResponse_Dec().pyclass - -DestroyNetworkRequestMsg = ns0.DestroyNetwork_Dec().pyclass - -DestroyNetworkResponseMsg = ns0.DestroyNetworkResponse_Dec().pyclass - -ValidateHostRequestMsg = ns0.ValidateHost_Dec().pyclass - -ValidateHostResponseMsg = ns0.ValidateHostResponse_Dec().pyclass - -ParseDescriptorRequestMsg = ns0.ParseDescriptor_Dec().pyclass - -ParseDescriptorResponseMsg = ns0.ParseDescriptorResponse_Dec().pyclass - -CreateImportSpecRequestMsg = ns0.CreateImportSpec_Dec().pyclass - -CreateImportSpecResponseMsg = ns0.CreateImportSpecResponse_Dec().pyclass - -CreateDescriptorRequestMsg = ns0.CreateDescriptor_Dec().pyclass - -CreateDescriptorResponseMsg = ns0.CreateDescriptorResponse_Dec().pyclass - -QueryPerfProviderSummaryRequestMsg = ns0.QueryPerfProviderSummary_Dec().pyclass - -QueryPerfProviderSummaryResponseMsg = ns0.QueryPerfProviderSummaryResponse_Dec().pyclass - -QueryAvailablePerfMetricRequestMsg = ns0.QueryAvailablePerfMetric_Dec().pyclass - -QueryAvailablePerfMetricResponseMsg = ns0.QueryAvailablePerfMetricResponse_Dec().pyclass - -QueryPerfCounterRequestMsg = ns0.QueryPerfCounter_Dec().pyclass - -QueryPerfCounterResponseMsg = ns0.QueryPerfCounterResponse_Dec().pyclass - -QueryPerfCounterByLevelRequestMsg = ns0.QueryPerfCounterByLevel_Dec().pyclass - -QueryPerfCounterByLevelResponseMsg = ns0.QueryPerfCounterByLevelResponse_Dec().pyclass - -QueryPerfRequestMsg = ns0.QueryPerf_Dec().pyclass - -QueryPerfResponseMsg = ns0.QueryPerfResponse_Dec().pyclass - -QueryPerfCompositeRequestMsg = ns0.QueryPerfComposite_Dec().pyclass - -QueryPerfCompositeResponseMsg = ns0.QueryPerfCompositeResponse_Dec().pyclass - -CreatePerfIntervalRequestMsg = ns0.CreatePerfInterval_Dec().pyclass - -CreatePerfIntervalResponseMsg = ns0.CreatePerfIntervalResponse_Dec().pyclass - -RemovePerfIntervalRequestMsg = ns0.RemovePerfInterval_Dec().pyclass - -RemovePerfIntervalResponseMsg = ns0.RemovePerfIntervalResponse_Dec().pyclass - -UpdatePerfIntervalRequestMsg = ns0.UpdatePerfInterval_Dec().pyclass - -UpdatePerfIntervalResponseMsg = ns0.UpdatePerfIntervalResponse_Dec().pyclass - -GetDatabaseSizeEstimateRequestMsg = ns0.GetDatabaseSizeEstimate_Dec().pyclass - -GetDatabaseSizeEstimateResponseMsg = ns0.GetDatabaseSizeEstimateResponse_Dec().pyclass - -UpdateConfigRequestMsg = ns0.UpdateConfig_Dec().pyclass - -UpdateConfigResponseMsg = ns0.UpdateConfigResponse_Dec().pyclass - -MoveIntoResourcePoolRequestMsg = ns0.MoveIntoResourcePool_Dec().pyclass - -MoveIntoResourcePoolResponseMsg = ns0.MoveIntoResourcePoolResponse_Dec().pyclass - -UpdateChildResourceConfigurationRequestMsg = ns0.UpdateChildResourceConfiguration_Dec().pyclass - -UpdateChildResourceConfigurationResponseMsg = ns0.UpdateChildResourceConfigurationResponse_Dec().pyclass - -CreateResourcePoolRequestMsg = ns0.CreateResourcePool_Dec().pyclass - -CreateResourcePoolResponseMsg = ns0.CreateResourcePoolResponse_Dec().pyclass - -DestroyChildrenRequestMsg = ns0.DestroyChildren_Dec().pyclass - -DestroyChildrenResponseMsg = ns0.DestroyChildrenResponse_Dec().pyclass - -CreateVAppRequestMsg = ns0.CreateVApp_Dec().pyclass - -CreateVAppResponseMsg = ns0.CreateVAppResponse_Dec().pyclass - -CreateChildVMRequestMsg = ns0.CreateChildVM_Dec().pyclass - -CreateChildVMResponseMsg = ns0.CreateChildVMResponse_Dec().pyclass - -CreateChildVM_TaskRequestMsg = ns0.CreateChildVM_Task_Dec().pyclass - -CreateChildVM_TaskResponseMsg = ns0.CreateChildVM_TaskResponse_Dec().pyclass - -RegisterChildVMRequestMsg = ns0.RegisterChildVM_Dec().pyclass - -RegisterChildVMResponseMsg = ns0.RegisterChildVMResponse_Dec().pyclass - -RegisterChildVM_TaskRequestMsg = ns0.RegisterChildVM_Task_Dec().pyclass - -RegisterChildVM_TaskResponseMsg = ns0.RegisterChildVM_TaskResponse_Dec().pyclass - -ImportVAppRequestMsg = ns0.ImportVApp_Dec().pyclass - -ImportVAppResponseMsg = ns0.ImportVAppResponse_Dec().pyclass - -FindByUuidRequestMsg = ns0.FindByUuid_Dec().pyclass - -FindByUuidResponseMsg = ns0.FindByUuidResponse_Dec().pyclass - -FindByDatastorePathRequestMsg = ns0.FindByDatastorePath_Dec().pyclass - -FindByDatastorePathResponseMsg = ns0.FindByDatastorePathResponse_Dec().pyclass - -FindByDnsNameRequestMsg = ns0.FindByDnsName_Dec().pyclass - -FindByDnsNameResponseMsg = ns0.FindByDnsNameResponse_Dec().pyclass - -FindByIpRequestMsg = ns0.FindByIp_Dec().pyclass - -FindByIpResponseMsg = ns0.FindByIpResponse_Dec().pyclass - -FindByInventoryPathRequestMsg = ns0.FindByInventoryPath_Dec().pyclass - -FindByInventoryPathResponseMsg = ns0.FindByInventoryPathResponse_Dec().pyclass - -FindChildRequestMsg = ns0.FindChild_Dec().pyclass - -FindChildResponseMsg = ns0.FindChildResponse_Dec().pyclass - -FindAllByUuidRequestMsg = ns0.FindAllByUuid_Dec().pyclass - -FindAllByUuidResponseMsg = ns0.FindAllByUuidResponse_Dec().pyclass - -FindAllByDnsNameRequestMsg = ns0.FindAllByDnsName_Dec().pyclass - -FindAllByDnsNameResponseMsg = ns0.FindAllByDnsNameResponse_Dec().pyclass - -FindAllByIpRequestMsg = ns0.FindAllByIp_Dec().pyclass - -FindAllByIpResponseMsg = ns0.FindAllByIpResponse_Dec().pyclass - -CurrentTimeRequestMsg = ns0.CurrentTime_Dec().pyclass - -CurrentTimeResponseMsg = ns0.CurrentTimeResponse_Dec().pyclass - -RetrieveServiceContentRequestMsg = ns0.RetrieveServiceContent_Dec().pyclass - -RetrieveServiceContentResponseMsg = ns0.RetrieveServiceContentResponse_Dec().pyclass - -ValidateMigrationRequestMsg = ns0.ValidateMigration_Dec().pyclass - -ValidateMigrationResponseMsg = ns0.ValidateMigrationResponse_Dec().pyclass - -QueryVMotionCompatibilityRequestMsg = ns0.QueryVMotionCompatibility_Dec().pyclass - -QueryVMotionCompatibilityResponseMsg = ns0.QueryVMotionCompatibilityResponse_Dec().pyclass - -RetrieveProductComponentsRequestMsg = ns0.RetrieveProductComponents_Dec().pyclass - -RetrieveProductComponentsResponseMsg = ns0.RetrieveProductComponentsResponse_Dec().pyclass - -UpdateServiceMessageRequestMsg = ns0.UpdateServiceMessage_Dec().pyclass - -UpdateServiceMessageResponseMsg = ns0.UpdateServiceMessageResponse_Dec().pyclass - -LoginRequestMsg = ns0.Login_Dec().pyclass - -LoginResponseMsg = ns0.LoginResponse_Dec().pyclass - -LoginBySSPIRequestMsg = ns0.LoginBySSPI_Dec().pyclass - -LoginBySSPIResponseMsg = ns0.LoginBySSPIResponse_Dec().pyclass - -LogoutRequestMsg = ns0.Logout_Dec().pyclass - -LogoutResponseMsg = ns0.LogoutResponse_Dec().pyclass - -AcquireLocalTicketRequestMsg = ns0.AcquireLocalTicket_Dec().pyclass - -AcquireLocalTicketResponseMsg = ns0.AcquireLocalTicketResponse_Dec().pyclass - -TerminateSessionRequestMsg = ns0.TerminateSession_Dec().pyclass - -TerminateSessionResponseMsg = ns0.TerminateSessionResponse_Dec().pyclass - -SetLocaleRequestMsg = ns0.SetLocale_Dec().pyclass - -SetLocaleResponseMsg = ns0.SetLocaleResponse_Dec().pyclass - -LoginExtensionBySubjectNameRequestMsg = ns0.LoginExtensionBySubjectName_Dec().pyclass - -LoginExtensionBySubjectNameResponseMsg = ns0.LoginExtensionBySubjectNameResponse_Dec().pyclass - -ImpersonateUserRequestMsg = ns0.ImpersonateUser_Dec().pyclass - -ImpersonateUserResponseMsg = ns0.ImpersonateUserResponse_Dec().pyclass - -SessionIsActiveRequestMsg = ns0.SessionIsActive_Dec().pyclass - -SessionIsActiveResponseMsg = ns0.SessionIsActiveResponse_Dec().pyclass - -AcquireCloneTicketRequestMsg = ns0.AcquireCloneTicket_Dec().pyclass - -AcquireCloneTicketResponseMsg = ns0.AcquireCloneTicketResponse_Dec().pyclass - -CloneSessionRequestMsg = ns0.CloneSession_Dec().pyclass - -CloneSessionResponseMsg = ns0.CloneSessionResponse_Dec().pyclass - -CancelTaskRequestMsg = ns0.CancelTask_Dec().pyclass - -CancelTaskResponseMsg = ns0.CancelTaskResponse_Dec().pyclass - -UpdateProgressRequestMsg = ns0.UpdateProgress_Dec().pyclass - -UpdateProgressResponseMsg = ns0.UpdateProgressResponse_Dec().pyclass - -SetTaskStateRequestMsg = ns0.SetTaskState_Dec().pyclass - -SetTaskStateResponseMsg = ns0.SetTaskStateResponse_Dec().pyclass - -SetTaskDescriptionRequestMsg = ns0.SetTaskDescription_Dec().pyclass - -SetTaskDescriptionResponseMsg = ns0.SetTaskDescriptionResponse_Dec().pyclass - -ReadNextTasksRequestMsg = ns0.ReadNextTasks_Dec().pyclass - -ReadNextTasksResponseMsg = ns0.ReadNextTasksResponse_Dec().pyclass - -ReadPreviousTasksRequestMsg = ns0.ReadPreviousTasks_Dec().pyclass - -ReadPreviousTasksResponseMsg = ns0.ReadPreviousTasksResponse_Dec().pyclass - -CreateCollectorForTasksRequestMsg = ns0.CreateCollectorForTasks_Dec().pyclass - -CreateCollectorForTasksResponseMsg = ns0.CreateCollectorForTasksResponse_Dec().pyclass - -CreateTaskRequestMsg = ns0.CreateTask_Dec().pyclass - -CreateTaskResponseMsg = ns0.CreateTaskResponse_Dec().pyclass - -RetrieveUserGroupsRequestMsg = ns0.RetrieveUserGroups_Dec().pyclass - -RetrieveUserGroupsResponseMsg = ns0.RetrieveUserGroupsResponse_Dec().pyclass - -UpdateVAppConfigRequestMsg = ns0.UpdateVAppConfig_Dec().pyclass - -UpdateVAppConfigResponseMsg = ns0.UpdateVAppConfigResponse_Dec().pyclass - -CloneVAppRequestMsg = ns0.CloneVApp_Dec().pyclass - -CloneVAppResponseMsg = ns0.CloneVAppResponse_Dec().pyclass - -CloneVApp_TaskRequestMsg = ns0.CloneVApp_Task_Dec().pyclass - -CloneVApp_TaskResponseMsg = ns0.CloneVApp_TaskResponse_Dec().pyclass - -ExportVAppRequestMsg = ns0.ExportVApp_Dec().pyclass - -ExportVAppResponseMsg = ns0.ExportVAppResponse_Dec().pyclass - -PowerOnVAppRequestMsg = ns0.PowerOnVApp_Dec().pyclass - -PowerOnVAppResponseMsg = ns0.PowerOnVAppResponse_Dec().pyclass - -PowerOnVApp_TaskRequestMsg = ns0.PowerOnVApp_Task_Dec().pyclass - -PowerOnVApp_TaskResponseMsg = ns0.PowerOnVApp_TaskResponse_Dec().pyclass - -PowerOffVAppRequestMsg = ns0.PowerOffVApp_Dec().pyclass - -PowerOffVAppResponseMsg = ns0.PowerOffVAppResponse_Dec().pyclass - -PowerOffVApp_TaskRequestMsg = ns0.PowerOffVApp_Task_Dec().pyclass - -PowerOffVApp_TaskResponseMsg = ns0.PowerOffVApp_TaskResponse_Dec().pyclass - -unregisterVAppRequestMsg = ns0.unregisterVApp_Dec().pyclass - -unregisterVAppResponseMsg = ns0.unregisterVAppResponse_Dec().pyclass - -unregisterVApp_TaskRequestMsg = ns0.unregisterVApp_Task_Dec().pyclass - -unregisterVApp_TaskResponseMsg = ns0.unregisterVApp_TaskResponse_Dec().pyclass - -CreateVirtualDiskRequestMsg = ns0.CreateVirtualDisk_Dec().pyclass - -CreateVirtualDiskResponseMsg = ns0.CreateVirtualDiskResponse_Dec().pyclass - -CreateVirtualDisk_TaskRequestMsg = ns0.CreateVirtualDisk_Task_Dec().pyclass - -CreateVirtualDisk_TaskResponseMsg = ns0.CreateVirtualDisk_TaskResponse_Dec().pyclass - -DeleteVirtualDiskRequestMsg = ns0.DeleteVirtualDisk_Dec().pyclass - -DeleteVirtualDiskResponseMsg = ns0.DeleteVirtualDiskResponse_Dec().pyclass - -DeleteVirtualDisk_TaskRequestMsg = ns0.DeleteVirtualDisk_Task_Dec().pyclass - -DeleteVirtualDisk_TaskResponseMsg = ns0.DeleteVirtualDisk_TaskResponse_Dec().pyclass - -MoveVirtualDiskRequestMsg = ns0.MoveVirtualDisk_Dec().pyclass - -MoveVirtualDiskResponseMsg = ns0.MoveVirtualDiskResponse_Dec().pyclass - -MoveVirtualDisk_TaskRequestMsg = ns0.MoveVirtualDisk_Task_Dec().pyclass - -MoveVirtualDisk_TaskResponseMsg = ns0.MoveVirtualDisk_TaskResponse_Dec().pyclass - -CopyVirtualDiskRequestMsg = ns0.CopyVirtualDisk_Dec().pyclass - -CopyVirtualDiskResponseMsg = ns0.CopyVirtualDiskResponse_Dec().pyclass - -CopyVirtualDisk_TaskRequestMsg = ns0.CopyVirtualDisk_Task_Dec().pyclass - -CopyVirtualDisk_TaskResponseMsg = ns0.CopyVirtualDisk_TaskResponse_Dec().pyclass - -ExtendVirtualDiskRequestMsg = ns0.ExtendVirtualDisk_Dec().pyclass - -ExtendVirtualDiskResponseMsg = ns0.ExtendVirtualDiskResponse_Dec().pyclass - -ExtendVirtualDisk_TaskRequestMsg = ns0.ExtendVirtualDisk_Task_Dec().pyclass - -ExtendVirtualDisk_TaskResponseMsg = ns0.ExtendVirtualDisk_TaskResponse_Dec().pyclass - -QueryVirtualDiskFragmentationRequestMsg = ns0.QueryVirtualDiskFragmentation_Dec().pyclass - -QueryVirtualDiskFragmentationResponseMsg = ns0.QueryVirtualDiskFragmentationResponse_Dec().pyclass - -DefragmentVirtualDiskRequestMsg = ns0.DefragmentVirtualDisk_Dec().pyclass - -DefragmentVirtualDiskResponseMsg = ns0.DefragmentVirtualDiskResponse_Dec().pyclass - -DefragmentVirtualDisk_TaskRequestMsg = ns0.DefragmentVirtualDisk_Task_Dec().pyclass - -DefragmentVirtualDisk_TaskResponseMsg = ns0.DefragmentVirtualDisk_TaskResponse_Dec().pyclass - -ShrinkVirtualDiskRequestMsg = ns0.ShrinkVirtualDisk_Dec().pyclass - -ShrinkVirtualDiskResponseMsg = ns0.ShrinkVirtualDiskResponse_Dec().pyclass - -ShrinkVirtualDisk_TaskRequestMsg = ns0.ShrinkVirtualDisk_Task_Dec().pyclass - -ShrinkVirtualDisk_TaskResponseMsg = ns0.ShrinkVirtualDisk_TaskResponse_Dec().pyclass - -InflateVirtualDiskRequestMsg = ns0.InflateVirtualDisk_Dec().pyclass - -InflateVirtualDiskResponseMsg = ns0.InflateVirtualDiskResponse_Dec().pyclass - -InflateVirtualDisk_TaskRequestMsg = ns0.InflateVirtualDisk_Task_Dec().pyclass - -InflateVirtualDisk_TaskResponseMsg = ns0.InflateVirtualDisk_TaskResponse_Dec().pyclass - -EagerZeroVirtualDiskRequestMsg = ns0.EagerZeroVirtualDisk_Dec().pyclass - -EagerZeroVirtualDiskResponseMsg = ns0.EagerZeroVirtualDiskResponse_Dec().pyclass - -EagerZeroVirtualDisk_TaskRequestMsg = ns0.EagerZeroVirtualDisk_Task_Dec().pyclass - -EagerZeroVirtualDisk_TaskResponseMsg = ns0.EagerZeroVirtualDisk_TaskResponse_Dec().pyclass - -ZeroFillVirtualDiskRequestMsg = ns0.ZeroFillVirtualDisk_Dec().pyclass - -ZeroFillVirtualDiskResponseMsg = ns0.ZeroFillVirtualDiskResponse_Dec().pyclass - -ZeroFillVirtualDisk_TaskRequestMsg = ns0.ZeroFillVirtualDisk_Task_Dec().pyclass - -ZeroFillVirtualDisk_TaskResponseMsg = ns0.ZeroFillVirtualDisk_TaskResponse_Dec().pyclass - -SetVirtualDiskUuidRequestMsg = ns0.SetVirtualDiskUuid_Dec().pyclass - -SetVirtualDiskUuidResponseMsg = ns0.SetVirtualDiskUuidResponse_Dec().pyclass - -QueryVirtualDiskUuidRequestMsg = ns0.QueryVirtualDiskUuid_Dec().pyclass - -QueryVirtualDiskUuidResponseMsg = ns0.QueryVirtualDiskUuidResponse_Dec().pyclass - -QueryVirtualDiskGeometryRequestMsg = ns0.QueryVirtualDiskGeometry_Dec().pyclass - -QueryVirtualDiskGeometryResponseMsg = ns0.QueryVirtualDiskGeometryResponse_Dec().pyclass - -RefreshStorageInfoRequestMsg = ns0.RefreshStorageInfo_Dec().pyclass - -RefreshStorageInfoResponseMsg = ns0.RefreshStorageInfoResponse_Dec().pyclass - -CreateSnapshotRequestMsg = ns0.CreateSnapshot_Dec().pyclass - -CreateSnapshotResponseMsg = ns0.CreateSnapshotResponse_Dec().pyclass - -CreateSnapshot_TaskRequestMsg = ns0.CreateSnapshot_Task_Dec().pyclass - -CreateSnapshot_TaskResponseMsg = ns0.CreateSnapshot_TaskResponse_Dec().pyclass - -RevertToCurrentSnapshotRequestMsg = ns0.RevertToCurrentSnapshot_Dec().pyclass - -RevertToCurrentSnapshotResponseMsg = ns0.RevertToCurrentSnapshotResponse_Dec().pyclass - -RevertToCurrentSnapshot_TaskRequestMsg = ns0.RevertToCurrentSnapshot_Task_Dec().pyclass - -RevertToCurrentSnapshot_TaskResponseMsg = ns0.RevertToCurrentSnapshot_TaskResponse_Dec().pyclass - -RemoveAllSnapshotsRequestMsg = ns0.RemoveAllSnapshots_Dec().pyclass - -RemoveAllSnapshotsResponseMsg = ns0.RemoveAllSnapshotsResponse_Dec().pyclass - -RemoveAllSnapshots_TaskRequestMsg = ns0.RemoveAllSnapshots_Task_Dec().pyclass - -RemoveAllSnapshots_TaskResponseMsg = ns0.RemoveAllSnapshots_TaskResponse_Dec().pyclass - -ReconfigVMRequestMsg = ns0.ReconfigVM_Dec().pyclass - -ReconfigVMResponseMsg = ns0.ReconfigVMResponse_Dec().pyclass - -ReconfigVM_TaskRequestMsg = ns0.ReconfigVM_Task_Dec().pyclass - -ReconfigVM_TaskResponseMsg = ns0.ReconfigVM_TaskResponse_Dec().pyclass - -UpgradeVMRequestMsg = ns0.UpgradeVM_Dec().pyclass - -UpgradeVMResponseMsg = ns0.UpgradeVMResponse_Dec().pyclass - -UpgradeVM_TaskRequestMsg = ns0.UpgradeVM_Task_Dec().pyclass - -UpgradeVM_TaskResponseMsg = ns0.UpgradeVM_TaskResponse_Dec().pyclass - -ExtractOvfEnvironmentRequestMsg = ns0.ExtractOvfEnvironment_Dec().pyclass - -ExtractOvfEnvironmentResponseMsg = ns0.ExtractOvfEnvironmentResponse_Dec().pyclass - -PowerOnVMRequestMsg = ns0.PowerOnVM_Dec().pyclass - -PowerOnVMResponseMsg = ns0.PowerOnVMResponse_Dec().pyclass - -PowerOnVM_TaskRequestMsg = ns0.PowerOnVM_Task_Dec().pyclass - -PowerOnVM_TaskResponseMsg = ns0.PowerOnVM_TaskResponse_Dec().pyclass - -PowerOffVMRequestMsg = ns0.PowerOffVM_Dec().pyclass - -PowerOffVMResponseMsg = ns0.PowerOffVMResponse_Dec().pyclass - -PowerOffVM_TaskRequestMsg = ns0.PowerOffVM_Task_Dec().pyclass - -PowerOffVM_TaskResponseMsg = ns0.PowerOffVM_TaskResponse_Dec().pyclass - -SuspendVMRequestMsg = ns0.SuspendVM_Dec().pyclass - -SuspendVMResponseMsg = ns0.SuspendVMResponse_Dec().pyclass - -SuspendVM_TaskRequestMsg = ns0.SuspendVM_Task_Dec().pyclass - -SuspendVM_TaskResponseMsg = ns0.SuspendVM_TaskResponse_Dec().pyclass - -ResetVMRequestMsg = ns0.ResetVM_Dec().pyclass - -ResetVMResponseMsg = ns0.ResetVMResponse_Dec().pyclass - -ResetVM_TaskRequestMsg = ns0.ResetVM_Task_Dec().pyclass - -ResetVM_TaskResponseMsg = ns0.ResetVM_TaskResponse_Dec().pyclass - -ShutdownGuestRequestMsg = ns0.ShutdownGuest_Dec().pyclass - -ShutdownGuestResponseMsg = ns0.ShutdownGuestResponse_Dec().pyclass - -RebootGuestRequestMsg = ns0.RebootGuest_Dec().pyclass - -RebootGuestResponseMsg = ns0.RebootGuestResponse_Dec().pyclass - -StandbyGuestRequestMsg = ns0.StandbyGuest_Dec().pyclass - -StandbyGuestResponseMsg = ns0.StandbyGuestResponse_Dec().pyclass - -AnswerVMRequestMsg = ns0.AnswerVM_Dec().pyclass - -AnswerVMResponseMsg = ns0.AnswerVMResponse_Dec().pyclass - -CustomizeVMRequestMsg = ns0.CustomizeVM_Dec().pyclass - -CustomizeVMResponseMsg = ns0.CustomizeVMResponse_Dec().pyclass - -CustomizeVM_TaskRequestMsg = ns0.CustomizeVM_Task_Dec().pyclass - -CustomizeVM_TaskResponseMsg = ns0.CustomizeVM_TaskResponse_Dec().pyclass - -CheckCustomizationSpecRequestMsg = ns0.CheckCustomizationSpec_Dec().pyclass - -CheckCustomizationSpecResponseMsg = ns0.CheckCustomizationSpecResponse_Dec().pyclass - -MigrateVMRequestMsg = ns0.MigrateVM_Dec().pyclass - -MigrateVMResponseMsg = ns0.MigrateVMResponse_Dec().pyclass - -MigrateVM_TaskRequestMsg = ns0.MigrateVM_Task_Dec().pyclass - -MigrateVM_TaskResponseMsg = ns0.MigrateVM_TaskResponse_Dec().pyclass - -RelocateVMRequestMsg = ns0.RelocateVM_Dec().pyclass - -RelocateVMResponseMsg = ns0.RelocateVMResponse_Dec().pyclass - -RelocateVM_TaskRequestMsg = ns0.RelocateVM_Task_Dec().pyclass - -RelocateVM_TaskResponseMsg = ns0.RelocateVM_TaskResponse_Dec().pyclass - -CloneVMRequestMsg = ns0.CloneVM_Dec().pyclass - -CloneVMResponseMsg = ns0.CloneVMResponse_Dec().pyclass - -CloneVM_TaskRequestMsg = ns0.CloneVM_Task_Dec().pyclass - -CloneVM_TaskResponseMsg = ns0.CloneVM_TaskResponse_Dec().pyclass - -ExportVmRequestMsg = ns0.ExportVm_Dec().pyclass - -ExportVmResponseMsg = ns0.ExportVmResponse_Dec().pyclass - -MarkAsTemplateRequestMsg = ns0.MarkAsTemplate_Dec().pyclass - -MarkAsTemplateResponseMsg = ns0.MarkAsTemplateResponse_Dec().pyclass - -MarkAsVirtualMachineRequestMsg = ns0.MarkAsVirtualMachine_Dec().pyclass - -MarkAsVirtualMachineResponseMsg = ns0.MarkAsVirtualMachineResponse_Dec().pyclass - -UnregisterVMRequestMsg = ns0.UnregisterVM_Dec().pyclass - -UnregisterVMResponseMsg = ns0.UnregisterVMResponse_Dec().pyclass - -ResetGuestInformationRequestMsg = ns0.ResetGuestInformation_Dec().pyclass - -ResetGuestInformationResponseMsg = ns0.ResetGuestInformationResponse_Dec().pyclass - -MountToolsInstallerRequestMsg = ns0.MountToolsInstaller_Dec().pyclass - -MountToolsInstallerResponseMsg = ns0.MountToolsInstallerResponse_Dec().pyclass - -UnmountToolsInstallerRequestMsg = ns0.UnmountToolsInstaller_Dec().pyclass - -UnmountToolsInstallerResponseMsg = ns0.UnmountToolsInstallerResponse_Dec().pyclass - -UpgradeToolsRequestMsg = ns0.UpgradeTools_Dec().pyclass - -UpgradeToolsResponseMsg = ns0.UpgradeToolsResponse_Dec().pyclass - -UpgradeTools_TaskRequestMsg = ns0.UpgradeTools_Task_Dec().pyclass - -UpgradeTools_TaskResponseMsg = ns0.UpgradeTools_TaskResponse_Dec().pyclass - -AcquireMksTicketRequestMsg = ns0.AcquireMksTicket_Dec().pyclass - -AcquireMksTicketResponseMsg = ns0.AcquireMksTicketResponse_Dec().pyclass - -SetScreenResolutionRequestMsg = ns0.SetScreenResolution_Dec().pyclass - -SetScreenResolutionResponseMsg = ns0.SetScreenResolutionResponse_Dec().pyclass - -DefragmentAllDisksRequestMsg = ns0.DefragmentAllDisks_Dec().pyclass - -DefragmentAllDisksResponseMsg = ns0.DefragmentAllDisksResponse_Dec().pyclass - -CreateSecondaryVMRequestMsg = ns0.CreateSecondaryVM_Dec().pyclass - -CreateSecondaryVMResponseMsg = ns0.CreateSecondaryVMResponse_Dec().pyclass - -CreateSecondaryVM_TaskRequestMsg = ns0.CreateSecondaryVM_Task_Dec().pyclass - -CreateSecondaryVM_TaskResponseMsg = ns0.CreateSecondaryVM_TaskResponse_Dec().pyclass - -TurnOffFaultToleranceForVMRequestMsg = ns0.TurnOffFaultToleranceForVM_Dec().pyclass - -TurnOffFaultToleranceForVMResponseMsg = ns0.TurnOffFaultToleranceForVMResponse_Dec().pyclass - -TurnOffFaultToleranceForVM_TaskRequestMsg = ns0.TurnOffFaultToleranceForVM_Task_Dec().pyclass - -TurnOffFaultToleranceForVM_TaskResponseMsg = ns0.TurnOffFaultToleranceForVM_TaskResponse_Dec().pyclass - -MakePrimaryVMRequestMsg = ns0.MakePrimaryVM_Dec().pyclass - -MakePrimaryVMResponseMsg = ns0.MakePrimaryVMResponse_Dec().pyclass - -MakePrimaryVM_TaskRequestMsg = ns0.MakePrimaryVM_Task_Dec().pyclass - -MakePrimaryVM_TaskResponseMsg = ns0.MakePrimaryVM_TaskResponse_Dec().pyclass - -TerminateFaultTolerantVMRequestMsg = ns0.TerminateFaultTolerantVM_Dec().pyclass - -TerminateFaultTolerantVMResponseMsg = ns0.TerminateFaultTolerantVMResponse_Dec().pyclass - -TerminateFaultTolerantVM_TaskRequestMsg = ns0.TerminateFaultTolerantVM_Task_Dec().pyclass - -TerminateFaultTolerantVM_TaskResponseMsg = ns0.TerminateFaultTolerantVM_TaskResponse_Dec().pyclass - -DisableSecondaryVMRequestMsg = ns0.DisableSecondaryVM_Dec().pyclass - -DisableSecondaryVMResponseMsg = ns0.DisableSecondaryVMResponse_Dec().pyclass - -DisableSecondaryVM_TaskRequestMsg = ns0.DisableSecondaryVM_Task_Dec().pyclass - -DisableSecondaryVM_TaskResponseMsg = ns0.DisableSecondaryVM_TaskResponse_Dec().pyclass - -EnableSecondaryVMRequestMsg = ns0.EnableSecondaryVM_Dec().pyclass - -EnableSecondaryVMResponseMsg = ns0.EnableSecondaryVMResponse_Dec().pyclass - -EnableSecondaryVM_TaskRequestMsg = ns0.EnableSecondaryVM_Task_Dec().pyclass - -EnableSecondaryVM_TaskResponseMsg = ns0.EnableSecondaryVM_TaskResponse_Dec().pyclass - -SetDisplayTopologyRequestMsg = ns0.SetDisplayTopology_Dec().pyclass - -SetDisplayTopologyResponseMsg = ns0.SetDisplayTopologyResponse_Dec().pyclass - -StartRecordingRequestMsg = ns0.StartRecording_Dec().pyclass - -StartRecordingResponseMsg = ns0.StartRecordingResponse_Dec().pyclass - -StartRecording_TaskRequestMsg = ns0.StartRecording_Task_Dec().pyclass - -StartRecording_TaskResponseMsg = ns0.StartRecording_TaskResponse_Dec().pyclass - -StopRecordingRequestMsg = ns0.StopRecording_Dec().pyclass - -StopRecordingResponseMsg = ns0.StopRecordingResponse_Dec().pyclass - -StopRecording_TaskRequestMsg = ns0.StopRecording_Task_Dec().pyclass - -StopRecording_TaskResponseMsg = ns0.StopRecording_TaskResponse_Dec().pyclass - -StartReplayingRequestMsg = ns0.StartReplaying_Dec().pyclass - -StartReplayingResponseMsg = ns0.StartReplayingResponse_Dec().pyclass - -StartReplaying_TaskRequestMsg = ns0.StartReplaying_Task_Dec().pyclass - -StartReplaying_TaskResponseMsg = ns0.StartReplaying_TaskResponse_Dec().pyclass - -StopReplayingRequestMsg = ns0.StopReplaying_Dec().pyclass - -StopReplayingResponseMsg = ns0.StopReplayingResponse_Dec().pyclass - -StopReplaying_TaskRequestMsg = ns0.StopReplaying_Task_Dec().pyclass - -StopReplaying_TaskResponseMsg = ns0.StopReplaying_TaskResponse_Dec().pyclass - -PromoteDisksRequestMsg = ns0.PromoteDisks_Dec().pyclass - -PromoteDisksResponseMsg = ns0.PromoteDisksResponse_Dec().pyclass - -PromoteDisks_TaskRequestMsg = ns0.PromoteDisks_Task_Dec().pyclass - -PromoteDisks_TaskResponseMsg = ns0.PromoteDisks_TaskResponse_Dec().pyclass - -CreateScreenshotRequestMsg = ns0.CreateScreenshot_Dec().pyclass - -CreateScreenshotResponseMsg = ns0.CreateScreenshotResponse_Dec().pyclass - -CreateScreenshot_TaskRequestMsg = ns0.CreateScreenshot_Task_Dec().pyclass - -CreateScreenshot_TaskResponseMsg = ns0.CreateScreenshot_TaskResponse_Dec().pyclass - -QueryChangedDiskAreasRequestMsg = ns0.QueryChangedDiskAreas_Dec().pyclass - -QueryChangedDiskAreasResponseMsg = ns0.QueryChangedDiskAreasResponse_Dec().pyclass - -QueryUnownedFilesRequestMsg = ns0.QueryUnownedFiles_Dec().pyclass - -QueryUnownedFilesResponseMsg = ns0.QueryUnownedFilesResponse_Dec().pyclass - -RemoveAlarmRequestMsg = ns0.RemoveAlarm_Dec().pyclass - -RemoveAlarmResponseMsg = ns0.RemoveAlarmResponse_Dec().pyclass - -ReconfigureAlarmRequestMsg = ns0.ReconfigureAlarm_Dec().pyclass - -ReconfigureAlarmResponseMsg = ns0.ReconfigureAlarmResponse_Dec().pyclass - -CreateAlarmRequestMsg = ns0.CreateAlarm_Dec().pyclass - -CreateAlarmResponseMsg = ns0.CreateAlarmResponse_Dec().pyclass - -GetAlarmRequestMsg = ns0.GetAlarm_Dec().pyclass - -GetAlarmResponseMsg = ns0.GetAlarmResponse_Dec().pyclass - -GetAlarmActionsEnabledRequestMsg = ns0.GetAlarmActionsEnabled_Dec().pyclass - -GetAlarmActionsEnabledResponseMsg = ns0.GetAlarmActionsEnabledResponse_Dec().pyclass - -SetAlarmActionsEnabledRequestMsg = ns0.SetAlarmActionsEnabled_Dec().pyclass - -SetAlarmActionsEnabledResponseMsg = ns0.SetAlarmActionsEnabledResponse_Dec().pyclass - -GetAlarmStateRequestMsg = ns0.GetAlarmState_Dec().pyclass - -GetAlarmStateResponseMsg = ns0.GetAlarmStateResponse_Dec().pyclass - -AcknowledgeAlarmRequestMsg = ns0.AcknowledgeAlarm_Dec().pyclass - -AcknowledgeAlarmResponseMsg = ns0.AcknowledgeAlarmResponse_Dec().pyclass - -DVPortgroupReconfigureRequestMsg = ns0.DVPortgroupReconfigure_Dec().pyclass - -DVPortgroupReconfigureResponseMsg = ns0.DVPortgroupReconfigureResponse_Dec().pyclass - -DVSManagerQueryAvailableSwitchSpecRequestMsg = ns0.DVSManagerQueryAvailableSwitchSpec_Dec().pyclass - -DVSManagerQueryAvailableSwitchSpecResponseMsg = ns0.DVSManagerQueryAvailableSwitchSpecResponse_Dec().pyclass - -DVSManagerQueryCompatibleHostForNewDvsRequestMsg = ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec().pyclass - -DVSManagerQueryCompatibleHostForNewDvsResponseMsg = ns0.DVSManagerQueryCompatibleHostForNewDvsResponse_Dec().pyclass - -DVSManagerQueryCompatibleHostForExistingDvsRequestMsg = ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec().pyclass - -DVSManagerQueryCompatibleHostForExistingDvsResponseMsg = ns0.DVSManagerQueryCompatibleHostForExistingDvsResponse_Dec().pyclass - -DVSManagerQueryCompatibleHostSpecRequestMsg = ns0.DVSManagerQueryCompatibleHostSpec_Dec().pyclass - -DVSManagerQueryCompatibleHostSpecResponseMsg = ns0.DVSManagerQueryCompatibleHostSpecResponse_Dec().pyclass - -DVSManagerQuerySwitchByUuidRequestMsg = ns0.DVSManagerQuerySwitchByUuid_Dec().pyclass - -DVSManagerQuerySwitchByUuidResponseMsg = ns0.DVSManagerQuerySwitchByUuidResponse_Dec().pyclass - -DVSManagerQueryDvsConfigTargetRequestMsg = ns0.DVSManagerQueryDvsConfigTarget_Dec().pyclass - -DVSManagerQueryDvsConfigTargetResponseMsg = ns0.DVSManagerQueryDvsConfigTargetResponse_Dec().pyclass - -ReadNextEventsRequestMsg = ns0.ReadNextEvents_Dec().pyclass - -ReadNextEventsResponseMsg = ns0.ReadNextEventsResponse_Dec().pyclass - -ReadPreviousEventsRequestMsg = ns0.ReadPreviousEvents_Dec().pyclass - -ReadPreviousEventsResponseMsg = ns0.ReadPreviousEventsResponse_Dec().pyclass - -RetrieveArgumentDescriptionRequestMsg = ns0.RetrieveArgumentDescription_Dec().pyclass - -RetrieveArgumentDescriptionResponseMsg = ns0.RetrieveArgumentDescriptionResponse_Dec().pyclass - -CreateCollectorForEventsRequestMsg = ns0.CreateCollectorForEvents_Dec().pyclass - -CreateCollectorForEventsResponseMsg = ns0.CreateCollectorForEventsResponse_Dec().pyclass - -LogUserEventRequestMsg = ns0.LogUserEvent_Dec().pyclass - -LogUserEventResponseMsg = ns0.LogUserEventResponse_Dec().pyclass - -QueryEventsRequestMsg = ns0.QueryEvents_Dec().pyclass - -QueryEventsResponseMsg = ns0.QueryEventsResponse_Dec().pyclass - -PostEventRequestMsg = ns0.PostEvent_Dec().pyclass - -PostEventResponseMsg = ns0.PostEventResponse_Dec().pyclass - -ReconfigureAutostartRequestMsg = ns0.ReconfigureAutostart_Dec().pyclass - -ReconfigureAutostartResponseMsg = ns0.ReconfigureAutostartResponse_Dec().pyclass - -AutoStartPowerOnRequestMsg = ns0.AutoStartPowerOn_Dec().pyclass - -AutoStartPowerOnResponseMsg = ns0.AutoStartPowerOnResponse_Dec().pyclass - -AutoStartPowerOffRequestMsg = ns0.AutoStartPowerOff_Dec().pyclass - -AutoStartPowerOffResponseMsg = ns0.AutoStartPowerOffResponse_Dec().pyclass - -QueryBootDevicesRequestMsg = ns0.QueryBootDevices_Dec().pyclass - -QueryBootDevicesResponseMsg = ns0.QueryBootDevicesResponse_Dec().pyclass - -UpdateBootDeviceRequestMsg = ns0.UpdateBootDevice_Dec().pyclass - -UpdateBootDeviceResponseMsg = ns0.UpdateBootDeviceResponse_Dec().pyclass - -EnableHyperThreadingRequestMsg = ns0.EnableHyperThreading_Dec().pyclass - -EnableHyperThreadingResponseMsg = ns0.EnableHyperThreadingResponse_Dec().pyclass - -DisableHyperThreadingRequestMsg = ns0.DisableHyperThreading_Dec().pyclass - -DisableHyperThreadingResponseMsg = ns0.DisableHyperThreadingResponse_Dec().pyclass - -SearchDatastoreRequestMsg = ns0.SearchDatastore_Dec().pyclass - -SearchDatastoreResponseMsg = ns0.SearchDatastoreResponse_Dec().pyclass - -SearchDatastore_TaskRequestMsg = ns0.SearchDatastore_Task_Dec().pyclass - -SearchDatastore_TaskResponseMsg = ns0.SearchDatastore_TaskResponse_Dec().pyclass - -SearchDatastoreSubFoldersRequestMsg = ns0.SearchDatastoreSubFolders_Dec().pyclass - -SearchDatastoreSubFoldersResponseMsg = ns0.SearchDatastoreSubFoldersResponse_Dec().pyclass - -SearchDatastoreSubFolders_TaskRequestMsg = ns0.SearchDatastoreSubFolders_Task_Dec().pyclass - -SearchDatastoreSubFolders_TaskResponseMsg = ns0.SearchDatastoreSubFolders_TaskResponse_Dec().pyclass - -DeleteFileRequestMsg = ns0.DeleteFile_Dec().pyclass - -DeleteFileResponseMsg = ns0.DeleteFileResponse_Dec().pyclass - -UpdateLocalSwapDatastoreRequestMsg = ns0.UpdateLocalSwapDatastore_Dec().pyclass - -UpdateLocalSwapDatastoreResponseMsg = ns0.UpdateLocalSwapDatastoreResponse_Dec().pyclass - -QueryAvailableDisksForVmfsRequestMsg = ns0.QueryAvailableDisksForVmfs_Dec().pyclass - -QueryAvailableDisksForVmfsResponseMsg = ns0.QueryAvailableDisksForVmfsResponse_Dec().pyclass - -QueryVmfsDatastoreCreateOptionsRequestMsg = ns0.QueryVmfsDatastoreCreateOptions_Dec().pyclass - -QueryVmfsDatastoreCreateOptionsResponseMsg = ns0.QueryVmfsDatastoreCreateOptionsResponse_Dec().pyclass - -CreateVmfsDatastoreRequestMsg = ns0.CreateVmfsDatastore_Dec().pyclass - -CreateVmfsDatastoreResponseMsg = ns0.CreateVmfsDatastoreResponse_Dec().pyclass - -QueryVmfsDatastoreExtendOptionsRequestMsg = ns0.QueryVmfsDatastoreExtendOptions_Dec().pyclass - -QueryVmfsDatastoreExtendOptionsResponseMsg = ns0.QueryVmfsDatastoreExtendOptionsResponse_Dec().pyclass - -QueryVmfsDatastoreExpandOptionsRequestMsg = ns0.QueryVmfsDatastoreExpandOptions_Dec().pyclass - -QueryVmfsDatastoreExpandOptionsResponseMsg = ns0.QueryVmfsDatastoreExpandOptionsResponse_Dec().pyclass - -ExtendVmfsDatastoreRequestMsg = ns0.ExtendVmfsDatastore_Dec().pyclass - -ExtendVmfsDatastoreResponseMsg = ns0.ExtendVmfsDatastoreResponse_Dec().pyclass - -ExpandVmfsDatastoreRequestMsg = ns0.ExpandVmfsDatastore_Dec().pyclass - -ExpandVmfsDatastoreResponseMsg = ns0.ExpandVmfsDatastoreResponse_Dec().pyclass - -CreateNasDatastoreRequestMsg = ns0.CreateNasDatastore_Dec().pyclass - -CreateNasDatastoreResponseMsg = ns0.CreateNasDatastoreResponse_Dec().pyclass - -CreateLocalDatastoreRequestMsg = ns0.CreateLocalDatastore_Dec().pyclass - -CreateLocalDatastoreResponseMsg = ns0.CreateLocalDatastoreResponse_Dec().pyclass - -RemoveDatastoreRequestMsg = ns0.RemoveDatastore_Dec().pyclass - -RemoveDatastoreResponseMsg = ns0.RemoveDatastoreResponse_Dec().pyclass - -ConfigureDatastorePrincipalRequestMsg = ns0.ConfigureDatastorePrincipal_Dec().pyclass - -ConfigureDatastorePrincipalResponseMsg = ns0.ConfigureDatastorePrincipalResponse_Dec().pyclass - -QueryUnresolvedVmfsVolumesRequestMsg = ns0.QueryUnresolvedVmfsVolumes_Dec().pyclass - -QueryUnresolvedVmfsVolumesResponseMsg = ns0.QueryUnresolvedVmfsVolumesResponse_Dec().pyclass - -ResignatureUnresolvedVmfsVolumeRequestMsg = ns0.ResignatureUnresolvedVmfsVolume_Dec().pyclass - -ResignatureUnresolvedVmfsVolumeResponseMsg = ns0.ResignatureUnresolvedVmfsVolumeResponse_Dec().pyclass - -ResignatureUnresolvedVmfsVolume_TaskRequestMsg = ns0.ResignatureUnresolvedVmfsVolume_Task_Dec().pyclass - -ResignatureUnresolvedVmfsVolume_TaskResponseMsg = ns0.ResignatureUnresolvedVmfsVolume_TaskResponse_Dec().pyclass - -UpdateDateTimeConfigRequestMsg = ns0.UpdateDateTimeConfig_Dec().pyclass - -UpdateDateTimeConfigResponseMsg = ns0.UpdateDateTimeConfigResponse_Dec().pyclass - -QueryAvailableTimeZonesRequestMsg = ns0.QueryAvailableTimeZones_Dec().pyclass - -QueryAvailableTimeZonesResponseMsg = ns0.QueryAvailableTimeZonesResponse_Dec().pyclass - -QueryDateTimeRequestMsg = ns0.QueryDateTime_Dec().pyclass - -QueryDateTimeResponseMsg = ns0.QueryDateTimeResponse_Dec().pyclass - -UpdateDateTimeRequestMsg = ns0.UpdateDateTime_Dec().pyclass - -UpdateDateTimeResponseMsg = ns0.UpdateDateTimeResponse_Dec().pyclass - -RefreshDateTimeSystemRequestMsg = ns0.RefreshDateTimeSystem_Dec().pyclass - -RefreshDateTimeSystemResponseMsg = ns0.RefreshDateTimeSystemResponse_Dec().pyclass - -QueryAvailablePartitionRequestMsg = ns0.QueryAvailablePartition_Dec().pyclass - -QueryAvailablePartitionResponseMsg = ns0.QueryAvailablePartitionResponse_Dec().pyclass - -SelectActivePartitionRequestMsg = ns0.SelectActivePartition_Dec().pyclass - -SelectActivePartitionResponseMsg = ns0.SelectActivePartitionResponse_Dec().pyclass - -QueryPartitionCreateOptionsRequestMsg = ns0.QueryPartitionCreateOptions_Dec().pyclass - -QueryPartitionCreateOptionsResponseMsg = ns0.QueryPartitionCreateOptionsResponse_Dec().pyclass - -QueryPartitionCreateDescRequestMsg = ns0.QueryPartitionCreateDesc_Dec().pyclass - -QueryPartitionCreateDescResponseMsg = ns0.QueryPartitionCreateDescResponse_Dec().pyclass - -CreateDiagnosticPartitionRequestMsg = ns0.CreateDiagnosticPartition_Dec().pyclass - -CreateDiagnosticPartitionResponseMsg = ns0.CreateDiagnosticPartitionResponse_Dec().pyclass - -UpdateDefaultPolicyRequestMsg = ns0.UpdateDefaultPolicy_Dec().pyclass - -UpdateDefaultPolicyResponseMsg = ns0.UpdateDefaultPolicyResponse_Dec().pyclass - -EnableRulesetRequestMsg = ns0.EnableRuleset_Dec().pyclass - -EnableRulesetResponseMsg = ns0.EnableRulesetResponse_Dec().pyclass - -DisableRulesetRequestMsg = ns0.DisableRuleset_Dec().pyclass - -DisableRulesetResponseMsg = ns0.DisableRulesetResponse_Dec().pyclass - -RefreshFirewallRequestMsg = ns0.RefreshFirewall_Dec().pyclass - -RefreshFirewallResponseMsg = ns0.RefreshFirewallResponse_Dec().pyclass - -ResetFirmwareToFactoryDefaultsRequestMsg = ns0.ResetFirmwareToFactoryDefaults_Dec().pyclass - -ResetFirmwareToFactoryDefaultsResponseMsg = ns0.ResetFirmwareToFactoryDefaultsResponse_Dec().pyclass - -BackupFirmwareConfigurationRequestMsg = ns0.BackupFirmwareConfiguration_Dec().pyclass - -BackupFirmwareConfigurationResponseMsg = ns0.BackupFirmwareConfigurationResponse_Dec().pyclass - -QueryFirmwareConfigUploadURLRequestMsg = ns0.QueryFirmwareConfigUploadURL_Dec().pyclass - -QueryFirmwareConfigUploadURLResponseMsg = ns0.QueryFirmwareConfigUploadURLResponse_Dec().pyclass - -RestoreFirmwareConfigurationRequestMsg = ns0.RestoreFirmwareConfiguration_Dec().pyclass - -RestoreFirmwareConfigurationResponseMsg = ns0.RestoreFirmwareConfigurationResponse_Dec().pyclass - -RefreshHealthStatusSystemRequestMsg = ns0.RefreshHealthStatusSystem_Dec().pyclass - -RefreshHealthStatusSystemResponseMsg = ns0.RefreshHealthStatusSystemResponse_Dec().pyclass - -ResetSystemHealthInfoRequestMsg = ns0.ResetSystemHealthInfo_Dec().pyclass - -ResetSystemHealthInfoResponseMsg = ns0.ResetSystemHealthInfoResponse_Dec().pyclass - -QueryModulesRequestMsg = ns0.QueryModules_Dec().pyclass - -QueryModulesResponseMsg = ns0.QueryModulesResponse_Dec().pyclass - -UpdateModuleOptionStringRequestMsg = ns0.UpdateModuleOptionString_Dec().pyclass - -UpdateModuleOptionStringResponseMsg = ns0.UpdateModuleOptionStringResponse_Dec().pyclass - -QueryConfiguredModuleOptionStringRequestMsg = ns0.QueryConfiguredModuleOptionString_Dec().pyclass - -QueryConfiguredModuleOptionStringResponseMsg = ns0.QueryConfiguredModuleOptionStringResponse_Dec().pyclass - -CreateUserRequestMsg = ns0.CreateUser_Dec().pyclass - -CreateUserResponseMsg = ns0.CreateUserResponse_Dec().pyclass - -UpdateUserRequestMsg = ns0.UpdateUser_Dec().pyclass - -UpdateUserResponseMsg = ns0.UpdateUserResponse_Dec().pyclass - -CreateGroupRequestMsg = ns0.CreateGroup_Dec().pyclass - -CreateGroupResponseMsg = ns0.CreateGroupResponse_Dec().pyclass - -RemoveUserRequestMsg = ns0.RemoveUser_Dec().pyclass - -RemoveUserResponseMsg = ns0.RemoveUserResponse_Dec().pyclass - -RemoveGroupRequestMsg = ns0.RemoveGroup_Dec().pyclass - -RemoveGroupResponseMsg = ns0.RemoveGroupResponse_Dec().pyclass - -AssignUserToGroupRequestMsg = ns0.AssignUserToGroup_Dec().pyclass - -AssignUserToGroupResponseMsg = ns0.AssignUserToGroupResponse_Dec().pyclass - -UnassignUserFromGroupRequestMsg = ns0.UnassignUserFromGroup_Dec().pyclass - -UnassignUserFromGroupResponseMsg = ns0.UnassignUserFromGroupResponse_Dec().pyclass - -ReconfigureServiceConsoleReservationRequestMsg = ns0.ReconfigureServiceConsoleReservation_Dec().pyclass - -ReconfigureServiceConsoleReservationResponseMsg = ns0.ReconfigureServiceConsoleReservationResponse_Dec().pyclass - -ReconfigureVirtualMachineReservationRequestMsg = ns0.ReconfigureVirtualMachineReservation_Dec().pyclass - -ReconfigureVirtualMachineReservationResponseMsg = ns0.ReconfigureVirtualMachineReservationResponse_Dec().pyclass - -UpdateNetworkConfigRequestMsg = ns0.UpdateNetworkConfig_Dec().pyclass - -UpdateNetworkConfigResponseMsg = ns0.UpdateNetworkConfigResponse_Dec().pyclass - -UpdateDnsConfigRequestMsg = ns0.UpdateDnsConfig_Dec().pyclass - -UpdateDnsConfigResponseMsg = ns0.UpdateDnsConfigResponse_Dec().pyclass - -UpdateIpRouteConfigRequestMsg = ns0.UpdateIpRouteConfig_Dec().pyclass - -UpdateIpRouteConfigResponseMsg = ns0.UpdateIpRouteConfigResponse_Dec().pyclass - -UpdateConsoleIpRouteConfigRequestMsg = ns0.UpdateConsoleIpRouteConfig_Dec().pyclass - -UpdateConsoleIpRouteConfigResponseMsg = ns0.UpdateConsoleIpRouteConfigResponse_Dec().pyclass - -UpdateIpRouteTableConfigRequestMsg = ns0.UpdateIpRouteTableConfig_Dec().pyclass - -UpdateIpRouteTableConfigResponseMsg = ns0.UpdateIpRouteTableConfigResponse_Dec().pyclass - -AddVirtualSwitchRequestMsg = ns0.AddVirtualSwitch_Dec().pyclass - -AddVirtualSwitchResponseMsg = ns0.AddVirtualSwitchResponse_Dec().pyclass - -RemoveVirtualSwitchRequestMsg = ns0.RemoveVirtualSwitch_Dec().pyclass - -RemoveVirtualSwitchResponseMsg = ns0.RemoveVirtualSwitchResponse_Dec().pyclass - -UpdateVirtualSwitchRequestMsg = ns0.UpdateVirtualSwitch_Dec().pyclass - -UpdateVirtualSwitchResponseMsg = ns0.UpdateVirtualSwitchResponse_Dec().pyclass - -AddPortGroupRequestMsg = ns0.AddPortGroup_Dec().pyclass - -AddPortGroupResponseMsg = ns0.AddPortGroupResponse_Dec().pyclass - -RemovePortGroupRequestMsg = ns0.RemovePortGroup_Dec().pyclass - -RemovePortGroupResponseMsg = ns0.RemovePortGroupResponse_Dec().pyclass - -UpdatePortGroupRequestMsg = ns0.UpdatePortGroup_Dec().pyclass - -UpdatePortGroupResponseMsg = ns0.UpdatePortGroupResponse_Dec().pyclass - -UpdatePhysicalNicLinkSpeedRequestMsg = ns0.UpdatePhysicalNicLinkSpeed_Dec().pyclass - -UpdatePhysicalNicLinkSpeedResponseMsg = ns0.UpdatePhysicalNicLinkSpeedResponse_Dec().pyclass - -QueryNetworkHintRequestMsg = ns0.QueryNetworkHint_Dec().pyclass - -QueryNetworkHintResponseMsg = ns0.QueryNetworkHintResponse_Dec().pyclass - -AddVirtualNicRequestMsg = ns0.AddVirtualNic_Dec().pyclass - -AddVirtualNicResponseMsg = ns0.AddVirtualNicResponse_Dec().pyclass - -RemoveVirtualNicRequestMsg = ns0.RemoveVirtualNic_Dec().pyclass - -RemoveVirtualNicResponseMsg = ns0.RemoveVirtualNicResponse_Dec().pyclass - -UpdateVirtualNicRequestMsg = ns0.UpdateVirtualNic_Dec().pyclass - -UpdateVirtualNicResponseMsg = ns0.UpdateVirtualNicResponse_Dec().pyclass - -AddServiceConsoleVirtualNicRequestMsg = ns0.AddServiceConsoleVirtualNic_Dec().pyclass - -AddServiceConsoleVirtualNicResponseMsg = ns0.AddServiceConsoleVirtualNicResponse_Dec().pyclass - -RemoveServiceConsoleVirtualNicRequestMsg = ns0.RemoveServiceConsoleVirtualNic_Dec().pyclass - -RemoveServiceConsoleVirtualNicResponseMsg = ns0.RemoveServiceConsoleVirtualNicResponse_Dec().pyclass - -UpdateServiceConsoleVirtualNicRequestMsg = ns0.UpdateServiceConsoleVirtualNic_Dec().pyclass - -UpdateServiceConsoleVirtualNicResponseMsg = ns0.UpdateServiceConsoleVirtualNicResponse_Dec().pyclass - -RestartServiceConsoleVirtualNicRequestMsg = ns0.RestartServiceConsoleVirtualNic_Dec().pyclass - -RestartServiceConsoleVirtualNicResponseMsg = ns0.RestartServiceConsoleVirtualNicResponse_Dec().pyclass - -RefreshNetworkSystemRequestMsg = ns0.RefreshNetworkSystem_Dec().pyclass - -RefreshNetworkSystemResponseMsg = ns0.RefreshNetworkSystemResponse_Dec().pyclass - -CheckHostPatchRequestMsg = ns0.CheckHostPatch_Dec().pyclass - -CheckHostPatchResponseMsg = ns0.CheckHostPatchResponse_Dec().pyclass - -CheckHostPatch_TaskRequestMsg = ns0.CheckHostPatch_Task_Dec().pyclass - -CheckHostPatch_TaskResponseMsg = ns0.CheckHostPatch_TaskResponse_Dec().pyclass - -ScanHostPatchRequestMsg = ns0.ScanHostPatch_Dec().pyclass - -ScanHostPatchResponseMsg = ns0.ScanHostPatchResponse_Dec().pyclass - -ScanHostPatch_TaskRequestMsg = ns0.ScanHostPatch_Task_Dec().pyclass - -ScanHostPatch_TaskResponseMsg = ns0.ScanHostPatch_TaskResponse_Dec().pyclass - -ScanHostPatchV2RequestMsg = ns0.ScanHostPatchV2_Dec().pyclass - -ScanHostPatchV2ResponseMsg = ns0.ScanHostPatchV2Response_Dec().pyclass - -ScanHostPatchV2_TaskRequestMsg = ns0.ScanHostPatchV2_Task_Dec().pyclass - -ScanHostPatchV2_TaskResponseMsg = ns0.ScanHostPatchV2_TaskResponse_Dec().pyclass - -StageHostPatchRequestMsg = ns0.StageHostPatch_Dec().pyclass - -StageHostPatchResponseMsg = ns0.StageHostPatchResponse_Dec().pyclass - -StageHostPatch_TaskRequestMsg = ns0.StageHostPatch_Task_Dec().pyclass - -StageHostPatch_TaskResponseMsg = ns0.StageHostPatch_TaskResponse_Dec().pyclass - -InstallHostPatchRequestMsg = ns0.InstallHostPatch_Dec().pyclass - -InstallHostPatchResponseMsg = ns0.InstallHostPatchResponse_Dec().pyclass - -InstallHostPatch_TaskRequestMsg = ns0.InstallHostPatch_Task_Dec().pyclass - -InstallHostPatch_TaskResponseMsg = ns0.InstallHostPatch_TaskResponse_Dec().pyclass - -InstallHostPatchV2RequestMsg = ns0.InstallHostPatchV2_Dec().pyclass - -InstallHostPatchV2ResponseMsg = ns0.InstallHostPatchV2Response_Dec().pyclass - -InstallHostPatchV2_TaskRequestMsg = ns0.InstallHostPatchV2_Task_Dec().pyclass - -InstallHostPatchV2_TaskResponseMsg = ns0.InstallHostPatchV2_TaskResponse_Dec().pyclass - -UninstallHostPatchRequestMsg = ns0.UninstallHostPatch_Dec().pyclass - -UninstallHostPatchResponseMsg = ns0.UninstallHostPatchResponse_Dec().pyclass - -UninstallHostPatch_TaskRequestMsg = ns0.UninstallHostPatch_Task_Dec().pyclass - -UninstallHostPatch_TaskResponseMsg = ns0.UninstallHostPatch_TaskResponse_Dec().pyclass - -QueryHostPatchRequestMsg = ns0.QueryHostPatch_Dec().pyclass - -QueryHostPatchResponseMsg = ns0.QueryHostPatchResponse_Dec().pyclass - -QueryHostPatch_TaskRequestMsg = ns0.QueryHostPatch_Task_Dec().pyclass - -QueryHostPatch_TaskResponseMsg = ns0.QueryHostPatch_TaskResponse_Dec().pyclass - -RefreshRequestMsg = ns0.Refresh_Dec().pyclass - -RefreshResponseMsg = ns0.RefreshResponse_Dec().pyclass - -UpdatePassthruConfigRequestMsg = ns0.UpdatePassthruConfig_Dec().pyclass - -UpdatePassthruConfigResponseMsg = ns0.UpdatePassthruConfigResponse_Dec().pyclass - -UpdateServicePolicyRequestMsg = ns0.UpdateServicePolicy_Dec().pyclass - -UpdateServicePolicyResponseMsg = ns0.UpdateServicePolicyResponse_Dec().pyclass - -StartServiceRequestMsg = ns0.StartService_Dec().pyclass - -StartServiceResponseMsg = ns0.StartServiceResponse_Dec().pyclass - -StopServiceRequestMsg = ns0.StopService_Dec().pyclass - -StopServiceResponseMsg = ns0.StopServiceResponse_Dec().pyclass - -RestartServiceRequestMsg = ns0.RestartService_Dec().pyclass - -RestartServiceResponseMsg = ns0.RestartServiceResponse_Dec().pyclass - -UninstallServiceRequestMsg = ns0.UninstallService_Dec().pyclass - -UninstallServiceResponseMsg = ns0.UninstallServiceResponse_Dec().pyclass - -RefreshServicesRequestMsg = ns0.RefreshServices_Dec().pyclass - -RefreshServicesResponseMsg = ns0.RefreshServicesResponse_Dec().pyclass - -ReconfigureSnmpAgentRequestMsg = ns0.ReconfigureSnmpAgent_Dec().pyclass - -ReconfigureSnmpAgentResponseMsg = ns0.ReconfigureSnmpAgentResponse_Dec().pyclass - -SendTestNotificationRequestMsg = ns0.SendTestNotification_Dec().pyclass - -SendTestNotificationResponseMsg = ns0.SendTestNotificationResponse_Dec().pyclass - -RetrieveDiskPartitionInfoRequestMsg = ns0.RetrieveDiskPartitionInfo_Dec().pyclass - -RetrieveDiskPartitionInfoResponseMsg = ns0.RetrieveDiskPartitionInfoResponse_Dec().pyclass - -ComputeDiskPartitionInfoRequestMsg = ns0.ComputeDiskPartitionInfo_Dec().pyclass - -ComputeDiskPartitionInfoResponseMsg = ns0.ComputeDiskPartitionInfoResponse_Dec().pyclass - -ComputeDiskPartitionInfoForResizeRequestMsg = ns0.ComputeDiskPartitionInfoForResize_Dec().pyclass - -ComputeDiskPartitionInfoForResizeResponseMsg = ns0.ComputeDiskPartitionInfoForResizeResponse_Dec().pyclass - -UpdateDiskPartitionsRequestMsg = ns0.UpdateDiskPartitions_Dec().pyclass - -UpdateDiskPartitionsResponseMsg = ns0.UpdateDiskPartitionsResponse_Dec().pyclass - -FormatVmfsRequestMsg = ns0.FormatVmfs_Dec().pyclass - -FormatVmfsResponseMsg = ns0.FormatVmfsResponse_Dec().pyclass - -RescanVmfsRequestMsg = ns0.RescanVmfs_Dec().pyclass - -RescanVmfsResponseMsg = ns0.RescanVmfsResponse_Dec().pyclass - -AttachVmfsExtentRequestMsg = ns0.AttachVmfsExtent_Dec().pyclass - -AttachVmfsExtentResponseMsg = ns0.AttachVmfsExtentResponse_Dec().pyclass - -ExpandVmfsExtentRequestMsg = ns0.ExpandVmfsExtent_Dec().pyclass - -ExpandVmfsExtentResponseMsg = ns0.ExpandVmfsExtentResponse_Dec().pyclass - -UpgradeVmfsRequestMsg = ns0.UpgradeVmfs_Dec().pyclass - -UpgradeVmfsResponseMsg = ns0.UpgradeVmfsResponse_Dec().pyclass - -UpgradeVmLayoutRequestMsg = ns0.UpgradeVmLayout_Dec().pyclass - -UpgradeVmLayoutResponseMsg = ns0.UpgradeVmLayoutResponse_Dec().pyclass - -QueryUnresolvedVmfsVolumeRequestMsg = ns0.QueryUnresolvedVmfsVolume_Dec().pyclass - -QueryUnresolvedVmfsVolumeResponseMsg = ns0.QueryUnresolvedVmfsVolumeResponse_Dec().pyclass - -ResolveMultipleUnresolvedVmfsVolumesRequestMsg = ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec().pyclass - -ResolveMultipleUnresolvedVmfsVolumesResponseMsg = ns0.ResolveMultipleUnresolvedVmfsVolumesResponse_Dec().pyclass - -UnmountForceMountedVmfsVolumeRequestMsg = ns0.UnmountForceMountedVmfsVolume_Dec().pyclass - -UnmountForceMountedVmfsVolumeResponseMsg = ns0.UnmountForceMountedVmfsVolumeResponse_Dec().pyclass - -RescanHbaRequestMsg = ns0.RescanHba_Dec().pyclass - -RescanHbaResponseMsg = ns0.RescanHbaResponse_Dec().pyclass - -RescanAllHbaRequestMsg = ns0.RescanAllHba_Dec().pyclass - -RescanAllHbaResponseMsg = ns0.RescanAllHbaResponse_Dec().pyclass - -UpdateSoftwareInternetScsiEnabledRequestMsg = ns0.UpdateSoftwareInternetScsiEnabled_Dec().pyclass - -UpdateSoftwareInternetScsiEnabledResponseMsg = ns0.UpdateSoftwareInternetScsiEnabledResponse_Dec().pyclass - -UpdateInternetScsiDiscoveryPropertiesRequestMsg = ns0.UpdateInternetScsiDiscoveryProperties_Dec().pyclass - -UpdateInternetScsiDiscoveryPropertiesResponseMsg = ns0.UpdateInternetScsiDiscoveryPropertiesResponse_Dec().pyclass - -UpdateInternetScsiAuthenticationPropertiesRequestMsg = ns0.UpdateInternetScsiAuthenticationProperties_Dec().pyclass - -UpdateInternetScsiAuthenticationPropertiesResponseMsg = ns0.UpdateInternetScsiAuthenticationPropertiesResponse_Dec().pyclass - -UpdateInternetScsiDigestPropertiesRequestMsg = ns0.UpdateInternetScsiDigestProperties_Dec().pyclass - -UpdateInternetScsiDigestPropertiesResponseMsg = ns0.UpdateInternetScsiDigestPropertiesResponse_Dec().pyclass - -UpdateInternetScsiAdvancedOptionsRequestMsg = ns0.UpdateInternetScsiAdvancedOptions_Dec().pyclass - -UpdateInternetScsiAdvancedOptionsResponseMsg = ns0.UpdateInternetScsiAdvancedOptionsResponse_Dec().pyclass - -UpdateInternetScsiIPPropertiesRequestMsg = ns0.UpdateInternetScsiIPProperties_Dec().pyclass - -UpdateInternetScsiIPPropertiesResponseMsg = ns0.UpdateInternetScsiIPPropertiesResponse_Dec().pyclass - -UpdateInternetScsiNameRequestMsg = ns0.UpdateInternetScsiName_Dec().pyclass - -UpdateInternetScsiNameResponseMsg = ns0.UpdateInternetScsiNameResponse_Dec().pyclass - -UpdateInternetScsiAliasRequestMsg = ns0.UpdateInternetScsiAlias_Dec().pyclass - -UpdateInternetScsiAliasResponseMsg = ns0.UpdateInternetScsiAliasResponse_Dec().pyclass - -AddInternetScsiSendTargetsRequestMsg = ns0.AddInternetScsiSendTargets_Dec().pyclass - -AddInternetScsiSendTargetsResponseMsg = ns0.AddInternetScsiSendTargetsResponse_Dec().pyclass - -RemoveInternetScsiSendTargetsRequestMsg = ns0.RemoveInternetScsiSendTargets_Dec().pyclass - -RemoveInternetScsiSendTargetsResponseMsg = ns0.RemoveInternetScsiSendTargetsResponse_Dec().pyclass - -AddInternetScsiStaticTargetsRequestMsg = ns0.AddInternetScsiStaticTargets_Dec().pyclass - -AddInternetScsiStaticTargetsResponseMsg = ns0.AddInternetScsiStaticTargetsResponse_Dec().pyclass - -RemoveInternetScsiStaticTargetsRequestMsg = ns0.RemoveInternetScsiStaticTargets_Dec().pyclass - -RemoveInternetScsiStaticTargetsResponseMsg = ns0.RemoveInternetScsiStaticTargetsResponse_Dec().pyclass - -EnableMultipathPathRequestMsg = ns0.EnableMultipathPath_Dec().pyclass - -EnableMultipathPathResponseMsg = ns0.EnableMultipathPathResponse_Dec().pyclass - -DisableMultipathPathRequestMsg = ns0.DisableMultipathPath_Dec().pyclass - -DisableMultipathPathResponseMsg = ns0.DisableMultipathPathResponse_Dec().pyclass - -SetMultipathLunPolicyRequestMsg = ns0.SetMultipathLunPolicy_Dec().pyclass - -SetMultipathLunPolicyResponseMsg = ns0.SetMultipathLunPolicyResponse_Dec().pyclass - -QueryPathSelectionPolicyOptionsRequestMsg = ns0.QueryPathSelectionPolicyOptions_Dec().pyclass - -QueryPathSelectionPolicyOptionsResponseMsg = ns0.QueryPathSelectionPolicyOptionsResponse_Dec().pyclass - -QueryStorageArrayTypePolicyOptionsRequestMsg = ns0.QueryStorageArrayTypePolicyOptions_Dec().pyclass - -QueryStorageArrayTypePolicyOptionsResponseMsg = ns0.QueryStorageArrayTypePolicyOptionsResponse_Dec().pyclass - -UpdateScsiLunDisplayNameRequestMsg = ns0.UpdateScsiLunDisplayName_Dec().pyclass - -UpdateScsiLunDisplayNameResponseMsg = ns0.UpdateScsiLunDisplayNameResponse_Dec().pyclass - -RefreshStorageSystemRequestMsg = ns0.RefreshStorageSystem_Dec().pyclass - -RefreshStorageSystemResponseMsg = ns0.RefreshStorageSystemResponse_Dec().pyclass - -UpdateIpConfigRequestMsg = ns0.UpdateIpConfig_Dec().pyclass - -UpdateIpConfigResponseMsg = ns0.UpdateIpConfigResponse_Dec().pyclass - -SelectVnicRequestMsg = ns0.SelectVnic_Dec().pyclass - -SelectVnicResponseMsg = ns0.SelectVnicResponse_Dec().pyclass - -DeselectVnicRequestMsg = ns0.DeselectVnic_Dec().pyclass - -DeselectVnicResponseMsg = ns0.DeselectVnicResponse_Dec().pyclass - -QueryNetConfigRequestMsg = ns0.QueryNetConfig_Dec().pyclass - -QueryNetConfigResponseMsg = ns0.QueryNetConfigResponse_Dec().pyclass - -VirtualNicManagerSelectVnicRequestMsg = ns0.VirtualNicManagerSelectVnic_Dec().pyclass - -VirtualNicManagerSelectVnicResponseMsg = ns0.VirtualNicManagerSelectVnicResponse_Dec().pyclass - -VirtualNicManagerDeselectVnicRequestMsg = ns0.VirtualNicManagerDeselectVnic_Dec().pyclass - -VirtualNicManagerDeselectVnicResponseMsg = ns0.VirtualNicManagerDeselectVnicResponse_Dec().pyclass - -QueryOptionsRequestMsg = ns0.QueryOptions_Dec().pyclass - -QueryOptionsResponseMsg = ns0.QueryOptionsResponse_Dec().pyclass - -UpdateOptionsRequestMsg = ns0.UpdateOptions_Dec().pyclass - -UpdateOptionsResponseMsg = ns0.UpdateOptionsResponse_Dec().pyclass - -ComplianceManagerCheckComplianceRequestMsg = ns0.ComplianceManagerCheckCompliance_Dec().pyclass - -ComplianceManagerCheckComplianceResponseMsg = ns0.ComplianceManagerCheckComplianceResponse_Dec().pyclass - -ComplianceManagerCheckCompliance_TaskRequestMsg = ns0.ComplianceManagerCheckCompliance_Task_Dec().pyclass - -ComplianceManagerCheckCompliance_TaskResponseMsg = ns0.ComplianceManagerCheckCompliance_TaskResponse_Dec().pyclass - -ComplianceManagerQueryComplianceStatusRequestMsg = ns0.ComplianceManagerQueryComplianceStatus_Dec().pyclass - -ComplianceManagerQueryComplianceStatusResponseMsg = ns0.ComplianceManagerQueryComplianceStatusResponse_Dec().pyclass - -ComplianceManagerClearComplianceStatusRequestMsg = ns0.ComplianceManagerClearComplianceStatus_Dec().pyclass - -ComplianceManagerClearComplianceStatusResponseMsg = ns0.ComplianceManagerClearComplianceStatusResponse_Dec().pyclass - -ComplianceManagerQueryExpressionMetadataRequestMsg = ns0.ComplianceManagerQueryExpressionMetadata_Dec().pyclass - -ComplianceManagerQueryExpressionMetadataResponseMsg = ns0.ComplianceManagerQueryExpressionMetadataResponse_Dec().pyclass - -ProfileDestroyRequestMsg = ns0.ProfileDestroy_Dec().pyclass - -ProfileDestroyResponseMsg = ns0.ProfileDestroyResponse_Dec().pyclass - -ProfileAssociateRequestMsg = ns0.ProfileAssociate_Dec().pyclass - -ProfileAssociateResponseMsg = ns0.ProfileAssociateResponse_Dec().pyclass - -ProfileDissociateRequestMsg = ns0.ProfileDissociate_Dec().pyclass - -ProfileDissociateResponseMsg = ns0.ProfileDissociateResponse_Dec().pyclass - -ProfileCheckComplianceRequestMsg = ns0.ProfileCheckCompliance_Dec().pyclass - -ProfileCheckComplianceResponseMsg = ns0.ProfileCheckComplianceResponse_Dec().pyclass - -ProfileCheckCompliance_TaskRequestMsg = ns0.ProfileCheckCompliance_Task_Dec().pyclass - -ProfileCheckCompliance_TaskResponseMsg = ns0.ProfileCheckCompliance_TaskResponse_Dec().pyclass - -ProfileExportProfileRequestMsg = ns0.ProfileExportProfile_Dec().pyclass - -ProfileExportProfileResponseMsg = ns0.ProfileExportProfileResponse_Dec().pyclass - -CreateProfileRequestMsg = ns0.CreateProfile_Dec().pyclass - -CreateProfileResponseMsg = ns0.CreateProfileResponse_Dec().pyclass - -ProfileQueryPolicyMetadataRequestMsg = ns0.ProfileQueryPolicyMetadata_Dec().pyclass - -ProfileQueryPolicyMetadataResponseMsg = ns0.ProfileQueryPolicyMetadataResponse_Dec().pyclass - -ProfileFindAssociatedProfileRequestMsg = ns0.ProfileFindAssociatedProfile_Dec().pyclass - -ProfileFindAssociatedProfileResponseMsg = ns0.ProfileFindAssociatedProfileResponse_Dec().pyclass - -ClusterProfileUpdateRequestMsg = ns0.ClusterProfileUpdate_Dec().pyclass - -ClusterProfileUpdateResponseMsg = ns0.ClusterProfileUpdateResponse_Dec().pyclass - -HostProfileUpdateReferenceHostRequestMsg = ns0.HostProfileUpdateReferenceHost_Dec().pyclass - -HostProfileUpdateReferenceHostResponseMsg = ns0.HostProfileUpdateReferenceHostResponse_Dec().pyclass - -HostProfileUpdateRequestMsg = ns0.HostProfileUpdate_Dec().pyclass - -HostProfileUpdateResponseMsg = ns0.HostProfileUpdateResponse_Dec().pyclass - -HostProfileExecuteRequestMsg = ns0.HostProfileExecute_Dec().pyclass - -HostProfileExecuteResponseMsg = ns0.HostProfileExecuteResponse_Dec().pyclass - -HostProfileApplyRequestMsg = ns0.HostProfileApply_Dec().pyclass - -HostProfileApplyResponseMsg = ns0.HostProfileApplyResponse_Dec().pyclass - -HostProfileApply_TaskRequestMsg = ns0.HostProfileApply_Task_Dec().pyclass - -HostProfileApply_TaskResponseMsg = ns0.HostProfileApply_TaskResponse_Dec().pyclass - -HostProfileGenerateConfigTaskListRequestMsg = ns0.HostProfileGenerateConfigTaskList_Dec().pyclass - -HostProfileGenerateConfigTaskListResponseMsg = ns0.HostProfileGenerateConfigTaskListResponse_Dec().pyclass - -HostProfileQueryProfileMetadataRequestMsg = ns0.HostProfileQueryProfileMetadata_Dec().pyclass - -HostProfileQueryProfileMetadataResponseMsg = ns0.HostProfileQueryProfileMetadataResponse_Dec().pyclass - -HostProfileCreateDefaultProfileRequestMsg = ns0.HostProfileCreateDefaultProfile_Dec().pyclass - -HostProfileCreateDefaultProfileResponseMsg = ns0.HostProfileCreateDefaultProfileResponse_Dec().pyclass - -RemoveScheduledTaskRequestMsg = ns0.RemoveScheduledTask_Dec().pyclass - -RemoveScheduledTaskResponseMsg = ns0.RemoveScheduledTaskResponse_Dec().pyclass - -ReconfigureScheduledTaskRequestMsg = ns0.ReconfigureScheduledTask_Dec().pyclass - -ReconfigureScheduledTaskResponseMsg = ns0.ReconfigureScheduledTaskResponse_Dec().pyclass - -RunScheduledTaskRequestMsg = ns0.RunScheduledTask_Dec().pyclass - -RunScheduledTaskResponseMsg = ns0.RunScheduledTaskResponse_Dec().pyclass - -CreateScheduledTaskRequestMsg = ns0.CreateScheduledTask_Dec().pyclass - -CreateScheduledTaskResponseMsg = ns0.CreateScheduledTaskResponse_Dec().pyclass - -RetrieveEntityScheduledTaskRequestMsg = ns0.RetrieveEntityScheduledTask_Dec().pyclass - -RetrieveEntityScheduledTaskResponseMsg = ns0.RetrieveEntityScheduledTaskResponse_Dec().pyclass - -CreateObjectScheduledTaskRequestMsg = ns0.CreateObjectScheduledTask_Dec().pyclass - -CreateObjectScheduledTaskResponseMsg = ns0.CreateObjectScheduledTaskResponse_Dec().pyclass - -RetrieveObjectScheduledTaskRequestMsg = ns0.RetrieveObjectScheduledTask_Dec().pyclass - -RetrieveObjectScheduledTaskResponseMsg = ns0.RetrieveObjectScheduledTaskResponse_Dec().pyclass - -OpenInventoryViewFolderRequestMsg = ns0.OpenInventoryViewFolder_Dec().pyclass - -OpenInventoryViewFolderResponseMsg = ns0.OpenInventoryViewFolderResponse_Dec().pyclass - -CloseInventoryViewFolderRequestMsg = ns0.CloseInventoryViewFolder_Dec().pyclass - -CloseInventoryViewFolderResponseMsg = ns0.CloseInventoryViewFolderResponse_Dec().pyclass - -ModifyListViewRequestMsg = ns0.ModifyListView_Dec().pyclass - -ModifyListViewResponseMsg = ns0.ModifyListViewResponse_Dec().pyclass - -ResetListViewRequestMsg = ns0.ResetListView_Dec().pyclass - -ResetListViewResponseMsg = ns0.ResetListViewResponse_Dec().pyclass - -ResetListViewFromViewRequestMsg = ns0.ResetListViewFromView_Dec().pyclass - -ResetListViewFromViewResponseMsg = ns0.ResetListViewFromViewResponse_Dec().pyclass - -DestroyViewRequestMsg = ns0.DestroyView_Dec().pyclass - -DestroyViewResponseMsg = ns0.DestroyViewResponse_Dec().pyclass - -CreateInventoryViewRequestMsg = ns0.CreateInventoryView_Dec().pyclass - -CreateInventoryViewResponseMsg = ns0.CreateInventoryViewResponse_Dec().pyclass - -CreateContainerViewRequestMsg = ns0.CreateContainerView_Dec().pyclass - -CreateContainerViewResponseMsg = ns0.CreateContainerViewResponse_Dec().pyclass - -CreateListViewRequestMsg = ns0.CreateListView_Dec().pyclass - -CreateListViewResponseMsg = ns0.CreateListViewResponse_Dec().pyclass - -CreateListViewFromViewRequestMsg = ns0.CreateListViewFromView_Dec().pyclass - -CreateListViewFromViewResponseMsg = ns0.CreateListViewFromViewResponse_Dec().pyclass - -RevertToSnapshotRequestMsg = ns0.RevertToSnapshot_Dec().pyclass - -RevertToSnapshotResponseMsg = ns0.RevertToSnapshotResponse_Dec().pyclass - -RevertToSnapshot_TaskRequestMsg = ns0.RevertToSnapshot_Task_Dec().pyclass - -RevertToSnapshot_TaskResponseMsg = ns0.RevertToSnapshot_TaskResponse_Dec().pyclass - -RemoveSnapshotRequestMsg = ns0.RemoveSnapshot_Dec().pyclass - -RemoveSnapshotResponseMsg = ns0.RemoveSnapshotResponse_Dec().pyclass - -RemoveSnapshot_TaskRequestMsg = ns0.RemoveSnapshot_Task_Dec().pyclass - -RemoveSnapshot_TaskResponseMsg = ns0.RemoveSnapshot_TaskResponse_Dec().pyclass - -RenameSnapshotRequestMsg = ns0.RenameSnapshot_Dec().pyclass - -RenameSnapshotResponseMsg = ns0.RenameSnapshotResponse_Dec().pyclass - -CheckCompatibilityRequestMsg = ns0.CheckCompatibility_Dec().pyclass - -CheckCompatibilityResponseMsg = ns0.CheckCompatibilityResponse_Dec().pyclass - -CheckCompatibility_TaskRequestMsg = ns0.CheckCompatibility_Task_Dec().pyclass - -CheckCompatibility_TaskResponseMsg = ns0.CheckCompatibility_TaskResponse_Dec().pyclass - -QueryVMotionCompatibilityExRequestMsg = ns0.QueryVMotionCompatibilityEx_Dec().pyclass - -QueryVMotionCompatibilityExResponseMsg = ns0.QueryVMotionCompatibilityExResponse_Dec().pyclass - -QueryVMotionCompatibilityEx_TaskRequestMsg = ns0.QueryVMotionCompatibilityEx_Task_Dec().pyclass - -QueryVMotionCompatibilityEx_TaskResponseMsg = ns0.QueryVMotionCompatibilityEx_TaskResponse_Dec().pyclass - -CheckMigrateRequestMsg = ns0.CheckMigrate_Dec().pyclass - -CheckMigrateResponseMsg = ns0.CheckMigrateResponse_Dec().pyclass - -CheckMigrate_TaskRequestMsg = ns0.CheckMigrate_Task_Dec().pyclass - -CheckMigrate_TaskResponseMsg = ns0.CheckMigrate_TaskResponse_Dec().pyclass - -CheckRelocateRequestMsg = ns0.CheckRelocate_Dec().pyclass - -CheckRelocateResponseMsg = ns0.CheckRelocateResponse_Dec().pyclass - -CheckRelocate_TaskRequestMsg = ns0.CheckRelocate_Task_Dec().pyclass - -CheckRelocate_TaskResponseMsg = ns0.CheckRelocate_TaskResponse_Dec().pyclass diff --git a/nova/virt/vmwareapi/VimService_services_types.py b/nova/virt/vmwareapi/VimService_services_types.py deleted file mode 100644 index f06ac99c9..000000000 --- a/nova/virt/vmwareapi/VimService_services_types.py +++ /dev/null @@ -1,72377 +0,0 @@ -################################################## -# VimService_services_types.py -# generated by ZSI.generate.wsdl2python -################################################## - - -import ZSI -import ZSI.TCcompound -from ZSI.schema import LocalElementDeclaration, ElementDeclaration, TypeDefinition, GTD, GED -from ZSI.generate.pyclass import pyclass_type - -############################## -# targetNamespace -# urn:vim25 -############################## - -class ns0: - targetNamespace = "urn:vim25" - - class DynamicArray_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DynamicArray") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DynamicArray_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"dynamicType"), aname="_dynamicType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"val"), aname="_val", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._dynamicType = None - self._val = [] - return - Holder.__name__ = "DynamicArray_Holder" - self.pyclass = Holder - - class DynamicData_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DynamicData") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DynamicData_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"dynamicType"), aname="_dynamicType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"dynamicProperty"), aname="_dynamicProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._dynamicType = None - self._dynamicProperty = [] - return - Holder.__name__ = "DynamicData_Holder" - self.pyclass = Holder - - class DynamicProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DynamicProperty") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DynamicProperty_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"val"), aname="_val", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._name = None - self._val = None - return - Holder.__name__ = "DynamicProperty_Holder" - self.pyclass = Holder - - class ArrayOfDynamicProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDynamicProperty") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDynamicProperty_Def.schema - TClist = [GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"DynamicProperty"), aname="_DynamicProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DynamicProperty = [] - return - Holder.__name__ = "ArrayOfDynamicProperty_Holder" - self.pyclass = Holder - - class KeyAnyValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "KeyAnyValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.KeyAnyValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.KeyAnyValue_Def.__bases__: - bases = list(ns0.KeyAnyValue_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.KeyAnyValue_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfKeyAnyValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfKeyAnyValue") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfKeyAnyValue_Def.schema - TClist = [GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"KeyAnyValue"), aname="_KeyAnyValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._KeyAnyValue = [] - return - Holder.__name__ = "ArrayOfKeyAnyValue_Holder" - self.pyclass = Holder - - class LocalizableMessage_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LocalizableMessage") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LocalizableMessage_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"arg"), aname="_arg", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LocalizableMessage_Def.__bases__: - bases = list(ns0.LocalizableMessage_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LocalizableMessage_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLocalizableMessage_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLocalizableMessage") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLocalizableMessage_Def.schema - TClist = [GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"LocalizableMessage"), aname="_LocalizableMessage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LocalizableMessage = [] - return - Holder.__name__ = "ArrayOfLocalizableMessage_Holder" - self.pyclass = Holder - - class HostCommunication_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCommunication") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCommunication_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.HostCommunication_Def.__bases__: - bases = list(ns0.HostCommunication_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.HostCommunication_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNotConnected_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNotConnected") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNotConnected_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostCommunication_Def not in ns0.HostNotConnected_Def.__bases__: - bases = list(ns0.HostNotConnected_Def.__bases__) - bases.insert(0, ns0.HostCommunication_Def) - ns0.HostNotConnected_Def.__bases__ = tuple(bases) - - ns0.HostCommunication_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNotReachable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNotReachable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNotReachable_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostCommunication_Def not in ns0.HostNotReachable_Def.__bases__: - bases = list(ns0.HostNotReachable_Def.__bases__) - bases.insert(0, ns0.HostCommunication_Def) - ns0.HostNotReachable_Def.__bases__ = tuple(bases) - - ns0.HostCommunication_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidArgument_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"invalidProperty"), aname="_invalidProperty", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.InvalidArgument_Def.__bases__: - bases = list(ns0.InvalidArgument_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.InvalidArgument_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidRequest_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidRequest") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidRequest_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.InvalidRequest_Def.__bases__: - bases = list(ns0.InvalidRequest_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.InvalidRequest_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidType_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidRequest_Def not in ns0.InvalidType_Def.__bases__: - bases = list(ns0.InvalidType_Def.__bases__) - bases.insert(0, ns0.InvalidRequest_Def) - ns0.InvalidType_Def.__bases__ = tuple(bases) - - ns0.InvalidRequest_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ManagedObjectNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ManagedObjectNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ManagedObjectNotFound_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.ManagedObjectNotFound_Def.__bases__: - bases = list(ns0.ManagedObjectNotFound_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.ManagedObjectNotFound_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MethodNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MethodNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MethodNotFound_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"receiver"), aname="_receiver", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"method"), aname="_method", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidRequest_Def not in ns0.MethodNotFound_Def.__bases__: - bases = list(ns0.MethodNotFound_Def.__bases__) - bases.insert(0, ns0.InvalidRequest_Def) - ns0.MethodNotFound_Def.__bases__ = tuple(bases) - - ns0.InvalidRequest_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotEnoughLicenses_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotEnoughLicenses") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotEnoughLicenses_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.NotEnoughLicenses_Def.__bases__: - bases = list(ns0.NotEnoughLicenses_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.NotEnoughLicenses_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotImplemented_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotImplemented") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotImplemented_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.NotImplemented_Def.__bases__: - bases = list(ns0.NotImplemented_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.NotImplemented_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.NotSupported_Def.__bases__: - bases = list(ns0.NotSupported_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.NotSupported_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RequestCanceled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RequestCanceled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RequestCanceled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.RequestCanceled_Def.__bases__: - bases = list(ns0.RequestCanceled_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.RequestCanceled_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SecurityError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SecurityError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SecurityError_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.SecurityError_Def.__bases__: - bases = list(ns0.SecurityError_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.SecurityError_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SystemError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SystemError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SystemError_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.SystemError_Def.__bases__: - bases = list(ns0.SystemError_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.SystemError_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnexpectedFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnexpectedFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnexpectedFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"faultName"), aname="_faultName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.UnexpectedFault_Def.__bases__: - bases = list(ns0.UnexpectedFault_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.UnexpectedFault_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidCollectorVersion_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidCollectorVersion") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidCollectorVersion_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MethodFault_Def not in ns0.InvalidCollectorVersion_Def.__bases__: - bases = list(ns0.InvalidCollectorVersion_Def.__bases__) - bases.insert(0, ns0.MethodFault_Def) - ns0.InvalidCollectorVersion_Def.__bases__ = tuple(bases) - - ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidProperty_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidProperty") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidProperty_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MethodFault_Def not in ns0.InvalidProperty_Def.__bases__: - bases = list(ns0.InvalidProperty_Def.__bases__) - bases.insert(0, ns0.MethodFault_Def) - ns0.InvalidProperty_Def.__bases__ = tuple(bases) - - ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PropertyFilterSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PropertyFilterSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PropertyFilterSpec_Def.schema - TClist = [GTD("urn:vim25","PropertySpec",lazy=True)(pname=(ns,"propSet"), aname="_propSet", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ObjectSpec",lazy=True)(pname=(ns,"objectSet"), aname="_objectSet", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PropertyFilterSpec_Def.__bases__: - bases = list(ns0.PropertyFilterSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PropertyFilterSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPropertyFilterSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPropertyFilterSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPropertyFilterSpec_Def.schema - TClist = [GTD("urn:vim25","PropertyFilterSpec",lazy=True)(pname=(ns,"PropertyFilterSpec"), aname="_PropertyFilterSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PropertyFilterSpec = [] - return - Holder.__name__ = "ArrayOfPropertyFilterSpec_Holder" - self.pyclass = Holder - - class PropertySpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PropertySpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PropertySpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"all"), aname="_all", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathSet"), aname="_pathSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PropertySpec_Def.__bases__: - bases = list(ns0.PropertySpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PropertySpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPropertySpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPropertySpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPropertySpec_Def.schema - TClist = [GTD("urn:vim25","PropertySpec",lazy=True)(pname=(ns,"PropertySpec"), aname="_PropertySpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PropertySpec = [] - return - Holder.__name__ = "ArrayOfPropertySpec_Holder" - self.pyclass = Holder - - class ObjectSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ObjectSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ObjectSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"skip"), aname="_skip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SelectionSpec",lazy=True)(pname=(ns,"selectSet"), aname="_selectSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ObjectSpec_Def.__bases__: - bases = list(ns0.ObjectSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ObjectSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfObjectSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfObjectSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfObjectSpec_Def.schema - TClist = [GTD("urn:vim25","ObjectSpec",lazy=True)(pname=(ns,"ObjectSpec"), aname="_ObjectSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ObjectSpec = [] - return - Holder.__name__ = "ArrayOfObjectSpec_Holder" - self.pyclass = Holder - - class SelectionSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SelectionSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SelectionSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.SelectionSpec_Def.__bases__: - bases = list(ns0.SelectionSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.SelectionSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfSelectionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfSelectionSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfSelectionSpec_Def.schema - TClist = [GTD("urn:vim25","SelectionSpec",lazy=True)(pname=(ns,"SelectionSpec"), aname="_SelectionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._SelectionSpec = [] - return - Holder.__name__ = "ArrayOfSelectionSpec_Holder" - self.pyclass = Holder - - class TraversalSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TraversalSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TraversalSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"skip"), aname="_skip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SelectionSpec",lazy=True)(pname=(ns,"selectSet"), aname="_selectSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SelectionSpec_Def not in ns0.TraversalSpec_Def.__bases__: - bases = list(ns0.TraversalSpec_Def.__bases__) - bases.insert(0, ns0.SelectionSpec_Def) - ns0.TraversalSpec_Def.__bases__ = tuple(bases) - - ns0.SelectionSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DestroyPropertyFilterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyPropertyFilterRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyPropertyFilterRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DestroyPropertyFilterRequestType_Holder" - self.pyclass = Holder - - class ObjectContent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ObjectContent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ObjectContent_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"propSet"), aname="_propSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MissingProperty",lazy=True)(pname=(ns,"missingSet"), aname="_missingSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ObjectContent_Def.__bases__: - bases = list(ns0.ObjectContent_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ObjectContent_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfObjectContent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfObjectContent") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfObjectContent_Def.schema - TClist = [GTD("urn:vim25","ObjectContent",lazy=True)(pname=(ns,"ObjectContent"), aname="_ObjectContent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ObjectContent = [] - return - Holder.__name__ = "ArrayOfObjectContent_Holder" - self.pyclass = Holder - - class UpdateSet_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UpdateSet") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UpdateSet_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyFilterUpdate",lazy=True)(pname=(ns,"filterSet"), aname="_filterSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.UpdateSet_Def.__bases__: - bases = list(ns0.UpdateSet_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.UpdateSet_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PropertyFilterUpdate_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PropertyFilterUpdate") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PropertyFilterUpdate_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ObjectUpdate",lazy=True)(pname=(ns,"objectSet"), aname="_objectSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MissingObject",lazy=True)(pname=(ns,"missingSet"), aname="_missingSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PropertyFilterUpdate_Def.__bases__: - bases = list(ns0.PropertyFilterUpdate_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PropertyFilterUpdate_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPropertyFilterUpdate_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPropertyFilterUpdate") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPropertyFilterUpdate_Def.schema - TClist = [GTD("urn:vim25","PropertyFilterUpdate",lazy=True)(pname=(ns,"PropertyFilterUpdate"), aname="_PropertyFilterUpdate", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PropertyFilterUpdate = [] - return - Holder.__name__ = "ArrayOfPropertyFilterUpdate_Holder" - self.pyclass = Holder - - class ObjectUpdateKind_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ObjectUpdateKind") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ObjectUpdate_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ObjectUpdate") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ObjectUpdate_Def.schema - TClist = [GTD("urn:vim25","ObjectUpdateKind",lazy=True)(pname=(ns,"kind"), aname="_kind", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyChange",lazy=True)(pname=(ns,"changeSet"), aname="_changeSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MissingProperty",lazy=True)(pname=(ns,"missingSet"), aname="_missingSet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ObjectUpdate_Def.__bases__: - bases = list(ns0.ObjectUpdate_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ObjectUpdate_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfObjectUpdate_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfObjectUpdate") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfObjectUpdate_Def.schema - TClist = [GTD("urn:vim25","ObjectUpdate",lazy=True)(pname=(ns,"ObjectUpdate"), aname="_ObjectUpdate", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ObjectUpdate = [] - return - Holder.__name__ = "ArrayOfObjectUpdate_Holder" - self.pyclass = Holder - - class PropertyChangeOp_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PropertyChangeOp") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class PropertyChange_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PropertyChange") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PropertyChange_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyChangeOp",lazy=True)(pname=(ns,"op"), aname="_op", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"val"), aname="_val", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PropertyChange_Def.__bases__: - bases = list(ns0.PropertyChange_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PropertyChange_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPropertyChange_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPropertyChange") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPropertyChange_Def.schema - TClist = [GTD("urn:vim25","PropertyChange",lazy=True)(pname=(ns,"PropertyChange"), aname="_PropertyChange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PropertyChange = [] - return - Holder.__name__ = "ArrayOfPropertyChange_Holder" - self.pyclass = Holder - - class MissingProperty_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingProperty") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingProperty_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.MissingProperty_Def.__bases__: - bases = list(ns0.MissingProperty_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.MissingProperty_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfMissingProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfMissingProperty") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfMissingProperty_Def.schema - TClist = [GTD("urn:vim25","MissingProperty",lazy=True)(pname=(ns,"MissingProperty"), aname="_MissingProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._MissingProperty = [] - return - Holder.__name__ = "ArrayOfMissingProperty_Holder" - self.pyclass = Holder - - class MissingObject_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingObject") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingObject_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.MissingObject_Def.__bases__: - bases = list(ns0.MissingObject_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.MissingObject_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfMissingObject_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfMissingObject") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfMissingObject_Def.schema - TClist = [GTD("urn:vim25","MissingObject",lazy=True)(pname=(ns,"MissingObject"), aname="_MissingObject", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._MissingObject = [] - return - Holder.__name__ = "ArrayOfMissingObject_Holder" - self.pyclass = Holder - - class CreateFilterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateFilterRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateFilterRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyFilterSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"partialUpdates"), aname="_partialUpdates", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - self._partialUpdates = None - return - Holder.__name__ = "CreateFilterRequestType_Holder" - self.pyclass = Holder - - class RetrievePropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrievePropertiesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrievePropertiesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PropertyFilterSpec",lazy=True)(pname=(ns,"specSet"), aname="_specSet", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._specSet = [] - return - Holder.__name__ = "RetrievePropertiesRequestType_Holder" - self.pyclass = Holder - - class CheckForUpdatesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckForUpdatesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckForUpdatesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._version = None - return - Holder.__name__ = "CheckForUpdatesRequestType_Holder" - self.pyclass = Holder - - class WaitForUpdatesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "WaitForUpdatesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.WaitForUpdatesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._version = None - return - Holder.__name__ = "WaitForUpdatesRequestType_Holder" - self.pyclass = Holder - - class CancelWaitForUpdatesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CancelWaitForUpdatesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CancelWaitForUpdatesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "CancelWaitForUpdatesRequestType_Holder" - self.pyclass = Holder - - class LocalizedMethodFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LocalizedMethodFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LocalizedMethodFault_Def.schema - TClist = [GTD("urn:vim25","MethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localizedMessage"), aname="_localizedMessage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LocalizedMethodFault_Def.__bases__: - bases = list(ns0.LocalizedMethodFault_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LocalizedMethodFault_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MethodFault_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MethodFault") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MethodFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"dynamicType"), aname="_dynamicType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DynamicProperty",lazy=True)(pname=(ns,"dynamicProperty"), aname="_dynamicProperty", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"faultCause"), aname="_faultCause", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"faultMessage"), aname="_faultMessage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._dynamicType = None - self._dynamicProperty = [] - self._faultCause = None - self._faultMessage = [] - return - Holder.__name__ = "MethodFault_Holder" - self.pyclass = Holder - - class ArrayOfMethodFault_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfMethodFault") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfMethodFault_Def.schema - TClist = [GTD("urn:vim25","MethodFault",lazy=True)(pname=(ns,"MethodFault"), aname="_MethodFault", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._MethodFault = [] - return - Holder.__name__ = "ArrayOfMethodFault_Holder" - self.pyclass = Holder - - class RuntimeFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RuntimeFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RuntimeFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MethodFault_Def not in ns0.RuntimeFault_Def.__bases__: - bases = list(ns0.RuntimeFault_Def.__bases__) - bases.insert(0, ns0.MethodFault_Def) - ns0.RuntimeFault_Def.__bases__ = tuple(bases) - - ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AboutInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AboutInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AboutInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"build"), aname="_build", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localeVersion"), aname="_localeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localeBuild"), aname="_localeBuild", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"osType"), aname="_osType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productLineId"), aname="_productLineId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"apiType"), aname="_apiType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"apiVersion"), aname="_apiVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseProductName"), aname="_licenseProductName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseProductVersion"), aname="_licenseProductVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AboutInfo_Def.__bases__: - bases = list(ns0.AboutInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AboutInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AuthorizationDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AuthorizationDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AuthorizationDescription_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"privilege"), aname="_privilege", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"privilegeGroup"), aname="_privilegeGroup", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AuthorizationDescription_Def.__bases__: - bases = list(ns0.AuthorizationDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AuthorizationDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class Permission_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Permission") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Permission_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"propagate"), aname="_propagate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.Permission_Def.__bases__: - bases = list(ns0.Permission_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.Permission_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPermission_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPermission") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPermission_Def.schema - TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"Permission"), aname="_Permission", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._Permission = [] - return - Holder.__name__ = "ArrayOfPermission_Holder" - self.pyclass = Holder - - class AuthorizationRole_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AuthorizationRole") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AuthorizationRole_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"system"), aname="_system", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privilege"), aname="_privilege", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AuthorizationRole_Def.__bases__: - bases = list(ns0.AuthorizationRole_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AuthorizationRole_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfAuthorizationRole_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAuthorizationRole") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAuthorizationRole_Def.schema - TClist = [GTD("urn:vim25","AuthorizationRole",lazy=True)(pname=(ns,"AuthorizationRole"), aname="_AuthorizationRole", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._AuthorizationRole = [] - return - Holder.__name__ = "ArrayOfAuthorizationRole_Holder" - self.pyclass = Holder - - class AuthorizationPrivilege_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AuthorizationPrivilege") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AuthorizationPrivilege_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"privId"), aname="_privId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"onParent"), aname="_onParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privGroupName"), aname="_privGroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AuthorizationPrivilege_Def.__bases__: - bases = list(ns0.AuthorizationPrivilege_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AuthorizationPrivilege_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfAuthorizationPrivilege_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAuthorizationPrivilege") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAuthorizationPrivilege_Def.schema - TClist = [GTD("urn:vim25","AuthorizationPrivilege",lazy=True)(pname=(ns,"AuthorizationPrivilege"), aname="_AuthorizationPrivilege", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._AuthorizationPrivilege = [] - return - Holder.__name__ = "ArrayOfAuthorizationPrivilege_Holder" - self.pyclass = Holder - - class AddAuthorizationRoleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddAuthorizationRoleRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddAuthorizationRoleRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privIds"), aname="_privIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._privIds = [] - return - Holder.__name__ = "AddAuthorizationRoleRequestType_Holder" - self.pyclass = Holder - - class RemoveAuthorizationRoleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveAuthorizationRoleRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveAuthorizationRoleRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"failIfUsed"), aname="_failIfUsed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._roleId = None - self._failIfUsed = None - return - Holder.__name__ = "RemoveAuthorizationRoleRequestType_Holder" - self.pyclass = Holder - - class UpdateAuthorizationRoleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateAuthorizationRoleRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateAuthorizationRoleRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privIds"), aname="_privIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._roleId = None - self._newName = None - self._privIds = [] - return - Holder.__name__ = "UpdateAuthorizationRoleRequestType_Holder" - self.pyclass = Holder - - class MergePermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MergePermissionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MergePermissionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"srcRoleId"), aname="_srcRoleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dstRoleId"), aname="_dstRoleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._srcRoleId = None - self._dstRoleId = None - return - Holder.__name__ = "MergePermissionsRequestType_Holder" - self.pyclass = Holder - - class RetrieveRolePermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveRolePermissionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveRolePermissionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._roleId = None - return - Holder.__name__ = "RetrieveRolePermissionsRequestType_Holder" - self.pyclass = Holder - - class RetrieveEntityPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveEntityPermissionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveEntityPermissionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inherited"), aname="_inherited", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._inherited = None - return - Holder.__name__ = "RetrieveEntityPermissionsRequestType_Holder" - self.pyclass = Holder - - class RetrieveAllPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveAllPermissionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveAllPermissionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RetrieveAllPermissionsRequestType_Holder" - self.pyclass = Holder - - class SetEntityPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetEntityPermissionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetEntityPermissionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"permission"), aname="_permission", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._permission = [] - return - Holder.__name__ = "SetEntityPermissionsRequestType_Holder" - self.pyclass = Holder - - class ResetEntityPermissionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetEntityPermissionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetEntityPermissionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"permission"), aname="_permission", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._permission = [] - return - Holder.__name__ = "ResetEntityPermissionsRequestType_Holder" - self.pyclass = Holder - - class RemoveEntityPermissionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveEntityPermissionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveEntityPermissionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"isGroup"), aname="_isGroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._user = None - self._isGroup = None - return - Holder.__name__ = "RemoveEntityPermissionRequestType_Holder" - self.pyclass = Holder - - class BoolPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "BoolPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.BoolPolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.BoolPolicy_Def.__bases__: - bases = list(ns0.BoolPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.BoolPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class Capability_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Capability") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Capability_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"provisioningSupported"), aname="_provisioningSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multiHostSupported"), aname="_multiHostSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"userShellAccessSupported"), aname="_userShellAccessSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EVCMode",lazy=True)(pname=(ns,"supportedEVCMode"), aname="_supportedEVCMode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.Capability_Def.__bases__: - bases = list(ns0.Capability_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.Capability_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterComputeResourceSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterComputeResourceSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterComputeResourceSummary_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"currentFailoverLevel"), aname="_currentFailoverLevel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasAdmissionControlInfo",lazy=True)(pname=(ns,"admissionControlInfo"), aname="_admissionControlInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVmotions"), aname="_numVmotions", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"targetBalance"), aname="_targetBalance", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"currentBalance"), aname="_currentBalance", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ComputeResourceSummary_Def not in ns0.ClusterComputeResourceSummary_Def.__bases__: - bases = list(ns0.ClusterComputeResourceSummary_Def.__bases__) - bases.insert(0, ns0.ComputeResourceSummary_Def) - ns0.ClusterComputeResourceSummary_Def.__bases__ = tuple(bases) - - ns0.ComputeResourceSummary_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReconfigureClusterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureClusterRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureClusterRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"modify"), aname="_modify", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - self._modify = None - return - Holder.__name__ = "ReconfigureClusterRequestType_Holder" - self.pyclass = Holder - - class ApplyRecommendationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ApplyRecommendationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ApplyRecommendationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._key = None - return - Holder.__name__ = "ApplyRecommendationRequestType_Holder" - self.pyclass = Holder - - class RecommendHostsForVmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RecommendHostsForVmRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RecommendHostsForVmRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - self._pool = None - return - Holder.__name__ = "RecommendHostsForVmRequestType_Holder" - self.pyclass = Holder - - class AddHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"asConnected"), aname="_asConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - self._asConnected = None - self._resourcePool = None - self._license = None - return - Holder.__name__ = "AddHostRequestType_Holder" - self.pyclass = Holder - - class MoveIntoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MoveIntoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MoveIntoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = [] - return - Holder.__name__ = "MoveIntoRequestType_Holder" - self.pyclass = Holder - - class MoveHostIntoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MoveHostIntoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MoveHostIntoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._resourcePool = None - return - Holder.__name__ = "MoveHostIntoRequestType_Holder" - self.pyclass = Holder - - class RefreshRecommendationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshRecommendationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshRecommendationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshRecommendationRequestType_Holder" - self.pyclass = Holder - - class RetrieveDasAdvancedRuntimeInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveDasAdvancedRuntimeInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RetrieveDasAdvancedRuntimeInfoRequestType_Holder" - self.pyclass = Holder - - class ComputeResourceSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComputeResourceSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComputeResourceSummary_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"totalCpu"), aname="_totalCpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"totalMemory"), aname="_totalMemory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuThreads"), aname="_numCpuThreads", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"effectiveCpu"), aname="_effectiveCpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"effectiveMemory"), aname="_effectiveMemory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numHosts"), aname="_numHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numEffectiveHosts"), aname="_numEffectiveHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ComputeResourceSummary_Def.__bases__: - bases = list(ns0.ComputeResourceSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ComputeResourceSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ComputeResourceConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComputeResourceConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComputeResourceConfigInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vmSwapPlacement"), aname="_vmSwapPlacement", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ComputeResourceConfigInfo_Def.__bases__: - bases = list(ns0.ComputeResourceConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ComputeResourceConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ComputeResourceConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComputeResourceConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComputeResourceConfigSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vmSwapPlacement"), aname="_vmSwapPlacement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ComputeResourceConfigSpec_Def.__bases__: - bases = list(ns0.ComputeResourceConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ComputeResourceConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReconfigureComputeResourceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureComputeResourceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureComputeResourceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComputeResourceConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"modify"), aname="_modify", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - self._modify = None - return - Holder.__name__ = "ReconfigureComputeResourceRequestType_Holder" - self.pyclass = Holder - - class ConfigSpecOperation_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ConfigSpecOperation") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class CustomFieldDef_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldDef") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldDef_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"managedObjectType"), aname="_managedObjectType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldDefPrivileges"), aname="_fieldDefPrivileges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldInstancePrivileges"), aname="_fieldInstancePrivileges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomFieldDef_Def.__bases__: - bases = list(ns0.CustomFieldDef_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomFieldDef_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfCustomFieldDef_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfCustomFieldDef") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfCustomFieldDef_Def.schema - TClist = [GTD("urn:vim25","CustomFieldDef",lazy=True)(pname=(ns,"CustomFieldDef"), aname="_CustomFieldDef", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._CustomFieldDef = [] - return - Holder.__name__ = "ArrayOfCustomFieldDef_Holder" - self.pyclass = Holder - - class CustomFieldValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldValue_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomFieldValue_Def.__bases__: - bases = list(ns0.CustomFieldValue_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomFieldValue_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfCustomFieldValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfCustomFieldValue") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfCustomFieldValue_Def.schema - TClist = [GTD("urn:vim25","CustomFieldValue",lazy=True)(pname=(ns,"CustomFieldValue"), aname="_CustomFieldValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._CustomFieldValue = [] - return - Holder.__name__ = "ArrayOfCustomFieldValue_Holder" - self.pyclass = Holder - - class CustomFieldStringValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldStringValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldStringValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomFieldValue_Def not in ns0.CustomFieldStringValue_Def.__bases__: - bases = list(ns0.CustomFieldStringValue_Def.__bases__) - bases.insert(0, ns0.CustomFieldValue_Def) - ns0.CustomFieldStringValue_Def.__bases__ = tuple(bases) - - ns0.CustomFieldValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AddCustomFieldDefRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddCustomFieldDefRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddCustomFieldDefRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"moType"), aname="_moType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldDefPolicy"), aname="_fieldDefPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PrivilegePolicyDef",lazy=True)(pname=(ns,"fieldPolicy"), aname="_fieldPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._moType = None - self._fieldDefPolicy = None - self._fieldPolicy = None - return - Holder.__name__ = "AddCustomFieldDefRequestType_Holder" - self.pyclass = Holder - - class RemoveCustomFieldDefRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveCustomFieldDefRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveCustomFieldDefRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._key = None - return - Holder.__name__ = "RemoveCustomFieldDefRequestType_Holder" - self.pyclass = Holder - - class RenameCustomFieldDefRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RenameCustomFieldDefRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RenameCustomFieldDefRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._key = None - self._name = None - return - Holder.__name__ = "RenameCustomFieldDefRequestType_Holder" - self.pyclass = Holder - - class SetFieldRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetFieldRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetFieldRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._key = None - self._value = None - return - Holder.__name__ = "SetFieldRequestType_Holder" - self.pyclass = Holder - - class DoesCustomizationSpecExistRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DoesCustomizationSpecExistRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DoesCustomizationSpecExistRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - return - Holder.__name__ = "DoesCustomizationSpecExistRequestType_Holder" - self.pyclass = Holder - - class GetCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "GetCustomizationSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.GetCustomizationSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - return - Holder.__name__ = "GetCustomizationSpecRequestType_Holder" - self.pyclass = Holder - - class CreateCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateCustomizationSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateCustomizationSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"item"), aname="_item", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._item = None - return - Holder.__name__ = "CreateCustomizationSpecRequestType_Holder" - self.pyclass = Holder - - class OverwriteCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "OverwriteCustomizationSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.OverwriteCustomizationSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"item"), aname="_item", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._item = None - return - Holder.__name__ = "OverwriteCustomizationSpecRequestType_Holder" - self.pyclass = Holder - - class DeleteCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DeleteCustomizationSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DeleteCustomizationSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - return - Holder.__name__ = "DeleteCustomizationSpecRequestType_Holder" - self.pyclass = Holder - - class DuplicateCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DuplicateCustomizationSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DuplicateCustomizationSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._newName = None - return - Holder.__name__ = "DuplicateCustomizationSpecRequestType_Holder" - self.pyclass = Holder - - class RenameCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RenameCustomizationSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RenameCustomizationSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._newName = None - return - Holder.__name__ = "RenameCustomizationSpecRequestType_Holder" - self.pyclass = Holder - - class CustomizationSpecItemToXmlRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CustomizationSpecItemToXmlRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CustomizationSpecItemToXmlRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"item"), aname="_item", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._item = None - return - Holder.__name__ = "CustomizationSpecItemToXmlRequestType_Holder" - self.pyclass = Holder - - class XmlToCustomizationSpecItemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "XmlToCustomizationSpecItemRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.XmlToCustomizationSpecItemRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"specItemXml"), aname="_specItemXml", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._specItemXml = None - return - Holder.__name__ = "XmlToCustomizationSpecItemRequestType_Holder" - self.pyclass = Holder - - class CheckCustomizationResourcesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckCustomizationResourcesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckCustomizationResourcesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestOs"), aname="_guestOs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._guestOs = None - return - Holder.__name__ = "CheckCustomizationResourcesRequestType_Holder" - self.pyclass = Holder - - class CustomizationSpecInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationSpecInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationSpecInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastUpdateTime"), aname="_lastUpdateTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationSpecInfo_Def.__bases__: - bases = list(ns0.CustomizationSpecInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationSpecInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfCustomizationSpecInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfCustomizationSpecInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfCustomizationSpecInfo_Def.schema - TClist = [GTD("urn:vim25","CustomizationSpecInfo",lazy=True)(pname=(ns,"CustomizationSpecInfo"), aname="_CustomizationSpecInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._CustomizationSpecInfo = [] - return - Holder.__name__ = "ArrayOfCustomizationSpecInfo_Holder" - self.pyclass = Holder - - class CustomizationSpecItem_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationSpecItem") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationSpecItem_Def.schema - TClist = [GTD("urn:vim25","CustomizationSpecInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationSpecItem_Def.__bases__: - bases = list(ns0.CustomizationSpecItem_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationSpecItem_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class QueryConnectionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryConnectionInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryConnectionInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"username"), aname="_username", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._hostname = None - self._port = None - self._username = None - self._password = None - self._sslThumbprint = None - return - Holder.__name__ = "QueryConnectionInfoRequestType_Holder" - self.pyclass = Holder - - class PowerOnMultiVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PowerOnMultiVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PowerOnMultiVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = [] - return - Holder.__name__ = "PowerOnMultiVMRequestType_Holder" - self.pyclass = Holder - - class DatastoreAccessible_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DatastoreAccessible") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DatastoreSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreSummary_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"freeSpace"), aname="_freeSpace", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"uncommitted"), aname="_uncommitted", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"accessible"), aname="_accessible", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multipleHostAccess"), aname="_multipleHostAccess", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatastoreSummary_Def.__bases__: - bases = list(ns0.DatastoreSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatastoreSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"freeSpace"), aname="_freeSpace", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxFileSize"), aname="_maxFileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatastoreInfo_Def.__bases__: - bases = list(ns0.DatastoreInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatastoreInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreCapability_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreCapability") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreCapability_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"directoryHierarchySupported"), aname="_directoryHierarchySupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rawDiskMappingsSupported"), aname="_rawDiskMappingsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"perFileThinProvisioningSupported"), aname="_perFileThinProvisioningSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatastoreCapability_Def.__bases__: - bases = list(ns0.DatastoreCapability_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatastoreCapability_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreHostMount_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreHostMount") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreHostMount_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMountInfo",lazy=True)(pname=(ns,"mountInfo"), aname="_mountInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatastoreHostMount_Def.__bases__: - bases = list(ns0.DatastoreHostMount_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatastoreHostMount_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDatastoreHostMount_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDatastoreHostMount") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDatastoreHostMount_Def.schema - TClist = [GTD("urn:vim25","DatastoreHostMount",lazy=True)(pname=(ns,"DatastoreHostMount"), aname="_DatastoreHostMount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DatastoreHostMount = [] - return - Holder.__name__ = "ArrayOfDatastoreHostMount_Holder" - self.pyclass = Holder - - class RefreshDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshDatastoreRequestType_Holder" - self.pyclass = Holder - - class RefreshDatastoreStorageInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshDatastoreStorageInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshDatastoreStorageInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshDatastoreStorageInfoRequestType_Holder" - self.pyclass = Holder - - class RenameDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RenameDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RenameDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._newName = None - return - Holder.__name__ = "RenameDatastoreRequestType_Holder" - self.pyclass = Holder - - class DestroyDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DestroyDatastoreRequestType_Holder" - self.pyclass = Holder - - class Description_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Description") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Description_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"summary"), aname="_summary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.Description_Def.__bases__: - bases = list(ns0.Description_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.Description_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DiagnosticManagerLogCreator_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DiagnosticManagerLogCreator") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DiagnosticManagerLogFormat_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DiagnosticManagerLogFormat") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DiagnosticManagerLogDescriptor_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DiagnosticManagerLogDescriptor") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DiagnosticManagerLogDescriptor_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fileName"), aname="_fileName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"creator"), aname="_creator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"format"), aname="_format", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mimeType"), aname="_mimeType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DiagnosticManagerLogDescriptor_Def.__bases__: - bases = list(ns0.DiagnosticManagerLogDescriptor_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DiagnosticManagerLogDescriptor_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDiagnosticManagerLogDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDiagnosticManagerLogDescriptor") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDiagnosticManagerLogDescriptor_Def.schema - TClist = [GTD("urn:vim25","DiagnosticManagerLogDescriptor",lazy=True)(pname=(ns,"DiagnosticManagerLogDescriptor"), aname="_DiagnosticManagerLogDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DiagnosticManagerLogDescriptor = [] - return - Holder.__name__ = "ArrayOfDiagnosticManagerLogDescriptor_Holder" - self.pyclass = Holder - - class DiagnosticManagerLogHeader_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DiagnosticManagerLogHeader") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DiagnosticManagerLogHeader_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineStart"), aname="_lineStart", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lineEnd"), aname="_lineEnd", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lineText"), aname="_lineText", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DiagnosticManagerLogHeader_Def.__bases__: - bases = list(ns0.DiagnosticManagerLogHeader_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DiagnosticManagerLogHeader_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DiagnosticManagerBundleInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DiagnosticManagerBundleInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DiagnosticManagerBundleInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"system"), aname="_system", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DiagnosticManagerBundleInfo_Def.__bases__: - bases = list(ns0.DiagnosticManagerBundleInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DiagnosticManagerBundleInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDiagnosticManagerBundleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDiagnosticManagerBundleInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDiagnosticManagerBundleInfo_Def.schema - TClist = [GTD("urn:vim25","DiagnosticManagerBundleInfo",lazy=True)(pname=(ns,"DiagnosticManagerBundleInfo"), aname="_DiagnosticManagerBundleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DiagnosticManagerBundleInfo = [] - return - Holder.__name__ = "ArrayOfDiagnosticManagerBundleInfo_Holder" - self.pyclass = Holder - - class QueryDescriptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryDescriptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryDescriptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "QueryDescriptionsRequestType_Holder" - self.pyclass = Holder - - class BrowseDiagnosticLogRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "BrowseDiagnosticLogRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.BrowseDiagnosticLogRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"start"), aname="_start", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lines"), aname="_lines", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._key = None - self._start = None - self._lines = None - return - Holder.__name__ = "BrowseDiagnosticLogRequestType_Holder" - self.pyclass = Holder - - class GenerateLogBundlesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "GenerateLogBundlesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.GenerateLogBundlesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"includeDefault"), aname="_includeDefault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._includeDefault = None - self._host = [] - return - Holder.__name__ = "GenerateLogBundlesRequestType_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchProductSpecOperationType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchProductSpecOperationType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DVSContactInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSContactInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSContactInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contact"), aname="_contact", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSContactInfo_Def.__bases__: - bases = list(ns0.DVSContactInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSContactInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSCapability_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSCapability") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSCapability_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"dvsOperationSupported"), aname="_dvsOperationSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dvPortGroupOperationSupported"), aname="_dvPortGroupOperationSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dvPortOperationSupported"), aname="_dvPortOperationSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostProductSpec",lazy=True)(pname=(ns,"compatibleHostComponentProductInfo"), aname="_compatibleHostComponentProductInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSCapability_Def.__bases__: - bases = list(ns0.DVSCapability_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSCapability_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSSummary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hostMember"), aname="_hostMember", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSContactInfo",lazy=True)(pname=(ns,"contact"), aname="_contact", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSSummary_Def.__bases__: - bases = list(ns0.DVSSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSPolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"autoPreInstallAllowed"), aname="_autoPreInstallAllowed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoUpgradeAllowed"), aname="_autoUpgradeAllowed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"partialUpgradeAllowed"), aname="_partialUpgradeAllowed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSPolicy_Def.__bases__: - bases = list(ns0.DVSPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSUplinkPortPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSUplinkPortPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSUplinkPortPolicy_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSUplinkPortPolicy_Def.__bases__: - bases = list(ns0.DVSUplinkPortPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSUplinkPortPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSNameArrayUplinkPortPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSNameArrayUplinkPortPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSNameArrayUplinkPortPolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"uplinkPortName"), aname="_uplinkPortName", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVSUplinkPortPolicy_Def not in ns0.DVSNameArrayUplinkPortPolicy_Def.__bases__: - bases = list(ns0.DVSNameArrayUplinkPortPolicy_Def.__bases__) - bases.insert(0, ns0.DVSUplinkPortPolicy_Def) - ns0.DVSNameArrayUplinkPortPolicy_Def.__bases__ = tuple(bases) - - ns0.DVSUplinkPortPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSConfigSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numStandalonePorts"), aname="_numStandalonePorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxPorts"), aname="_maxPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSUplinkPortPolicy",lazy=True)(pname=(ns,"uplinkPortPolicy"), aname="_uplinkPortPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"uplinkPortgroup"), aname="_uplinkPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMemberConfigSpec",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSContactInfo",lazy=True)(pname=(ns,"contact"), aname="_contact", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSConfigSpec_Def.__bases__: - bases = list(ns0.DVSConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSCreateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSCreateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSCreateSpec_Def.schema - TClist = [GTD("urn:vim25","DVSConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSCreateSpec_Def.__bases__: - bases = list(ns0.DVSCreateSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSCreateSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSConfigInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numStandalonePorts"), aname="_numStandalonePorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxPorts"), aname="_maxPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSUplinkPortPolicy",lazy=True)(pname=(ns,"uplinkPortPolicy"), aname="_uplinkPortPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"uplinkPortgroup"), aname="_uplinkPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMember",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"targetInfo"), aname="_targetInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSContactInfo",lazy=True)(pname=(ns,"contact"), aname="_contact", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"createTime"), aname="_createTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSConfigInfo_Def.__bases__: - bases = list(ns0.DVSConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSFetchKeyOfPortsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSFetchKeyOfPortsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSFetchKeyOfPortsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortCriteria",lazy=True)(pname=(ns,"criteria"), aname="_criteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._criteria = None - return - Holder.__name__ = "DVSFetchKeyOfPortsRequestType_Holder" - self.pyclass = Holder - - class DVSFetchPortsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSFetchPortsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSFetchPortsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortCriteria",lazy=True)(pname=(ns,"criteria"), aname="_criteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._criteria = None - return - Holder.__name__ = "DVSFetchPortsRequestType_Holder" - self.pyclass = Holder - - class DVSQueryUsedVlanIdRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSQueryUsedVlanIdRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSQueryUsedVlanIdRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DVSQueryUsedVlanIdRequestType_Holder" - self.pyclass = Holder - - class DVSReconfigureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSReconfigureRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSReconfigureRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "DVSReconfigureRequestType_Holder" - self.pyclass = Holder - - class DVSPerformProductSpecOperationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSPerformProductSpecOperationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSPerformProductSpecOperationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productSpec"), aname="_productSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._operation = None - self._productSpec = None - return - Holder.__name__ = "DVSPerformProductSpecOperationRequestType_Holder" - self.pyclass = Holder - - class DVSMergeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSMergeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSMergeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dvs = None - return - Holder.__name__ = "DVSMergeRequestType_Holder" - self.pyclass = Holder - - class DVSAddPortgroupsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSAddPortgroupsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSAddPortgroupsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = [] - return - Holder.__name__ = "DVSAddPortgroupsRequestType_Holder" - self.pyclass = Holder - - class DVSMovePortRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSMovePortRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSMovePortRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destinationPortgroupKey"), aname="_destinationPortgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._portKey = [] - self._destinationPortgroupKey = None - return - Holder.__name__ = "DVSMovePortRequestType_Holder" - self.pyclass = Holder - - class DVSUpdateCapabilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSUpdateCapabilityRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSUpdateCapabilityRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._capability = None - return - Holder.__name__ = "DVSUpdateCapabilityRequestType_Holder" - self.pyclass = Holder - - class ReconfigurePortRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigurePortRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigurePortRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortConfigSpec",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._port = [] - return - Holder.__name__ = "ReconfigurePortRequestType_Holder" - self.pyclass = Holder - - class DVSRefreshPortStateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSRefreshPortStateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSRefreshPortStateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKeys"), aname="_portKeys", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._portKeys = [] - return - Holder.__name__ = "DVSRefreshPortStateRequestType_Holder" - self.pyclass = Holder - - class DVSRectifyHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSRectifyHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSRectifyHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hosts"), aname="_hosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._hosts = [] - return - Holder.__name__ = "DVSRectifyHostRequestType_Holder" - self.pyclass = Holder - - class EVCMode_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCMode") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCMode_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vendorTier"), aname="_vendorTier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ElementDescription_Def not in ns0.EVCMode_Def.__bases__: - bases = list(ns0.EVCMode_Def.__bases__) - bases.insert(0, ns0.ElementDescription_Def) - ns0.EVCMode_Def.__bases__ = tuple(bases) - - ns0.ElementDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfEVCMode_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfEVCMode") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfEVCMode_Def.schema - TClist = [GTD("urn:vim25","EVCMode",lazy=True)(pname=(ns,"EVCMode"), aname="_EVCMode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._EVCMode = [] - return - Holder.__name__ = "ArrayOfEVCMode_Holder" - self.pyclass = Holder - - class ElementDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ElementDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ElementDescription_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Description_Def not in ns0.ElementDescription_Def.__bases__: - bases = list(ns0.ElementDescription_Def.__bases__) - bases.insert(0, ns0.Description_Def) - ns0.ElementDescription_Def.__bases__ = tuple(bases) - - ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfElementDescription_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfElementDescription") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfElementDescription_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"ElementDescription"), aname="_ElementDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ElementDescription = [] - return - Holder.__name__ = "ArrayOfElementDescription_Holder" - self.pyclass = Holder - - class EnumDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EnumDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EnumDescription_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"tags"), aname="_tags", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EnumDescription_Def.__bases__: - bases = list(ns0.EnumDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EnumDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfEnumDescription_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfEnumDescription") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfEnumDescription_Def.schema - TClist = [GTD("urn:vim25","EnumDescription",lazy=True)(pname=(ns,"EnumDescription"), aname="_EnumDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._EnumDescription = [] - return - Holder.__name__ = "ArrayOfEnumDescription_Holder" - self.pyclass = Holder - - class QueryConfigOptionDescriptorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryConfigOptionDescriptorRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryConfigOptionDescriptorRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryConfigOptionDescriptorRequestType_Holder" - self.pyclass = Holder - - class QueryConfigOptionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryConfigOptionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryConfigOptionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._key = None - self._host = None - return - Holder.__name__ = "QueryConfigOptionRequestType_Holder" - self.pyclass = Holder - - class QueryConfigTargetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryConfigTargetRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryConfigTargetRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "QueryConfigTargetRequestType_Holder" - self.pyclass = Holder - - class QueryTargetCapabilitiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryTargetCapabilitiesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryTargetCapabilitiesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "QueryTargetCapabilitiesRequestType_Holder" - self.pyclass = Holder - - class ExtendedDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtendedDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtendedDescription_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"messageCatalogKeyPrefix"), aname="_messageCatalogKeyPrefix", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"messageArg"), aname="_messageArg", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Description_Def not in ns0.ExtendedDescription_Def.__bases__: - bases = list(ns0.ExtendedDescription_Def.__bases__) - bases.insert(0, ns0.Description_Def) - ns0.ExtendedDescription_Def.__bases__ = tuple(bases) - - ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExtendedElementDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtendedElementDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtendedElementDescription_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"messageCatalogKeyPrefix"), aname="_messageCatalogKeyPrefix", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"messageArg"), aname="_messageArg", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ElementDescription_Def not in ns0.ExtendedElementDescription_Def.__bases__: - bases = list(ns0.ExtendedElementDescription_Def.__bases__) - bases.insert(0, ns0.ElementDescription_Def) - ns0.ExtendedElementDescription_Def.__bases__ = tuple(bases) - - ns0.ElementDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class setCustomValueRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "setCustomValueRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.setCustomValueRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._key = None - self._value = None - return - Holder.__name__ = "setCustomValueRequestType_Holder" - self.pyclass = Holder - - class ExtensionServerInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionServerInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionServerInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"company"), aname="_company", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adminEmail"), aname="_adminEmail", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionServerInfo_Def.__bases__: - bases = list(ns0.ExtensionServerInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionServerInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtensionServerInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtensionServerInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtensionServerInfo_Def.schema - TClist = [GTD("urn:vim25","ExtensionServerInfo",lazy=True)(pname=(ns,"ExtensionServerInfo"), aname="_ExtensionServerInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtensionServerInfo = [] - return - Holder.__name__ = "ArrayOfExtensionServerInfo_Holder" - self.pyclass = Holder - - class ExtensionClientInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionClientInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionClientInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"company"), aname="_company", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionClientInfo_Def.__bases__: - bases = list(ns0.ExtensionClientInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionClientInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtensionClientInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtensionClientInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtensionClientInfo_Def.schema - TClist = [GTD("urn:vim25","ExtensionClientInfo",lazy=True)(pname=(ns,"ExtensionClientInfo"), aname="_ExtensionClientInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtensionClientInfo = [] - return - Holder.__name__ = "ArrayOfExtensionClientInfo_Holder" - self.pyclass = Holder - - class ExtensionTaskTypeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionTaskTypeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionTaskTypeInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"taskID"), aname="_taskID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionTaskTypeInfo_Def.__bases__: - bases = list(ns0.ExtensionTaskTypeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionTaskTypeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtensionTaskTypeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtensionTaskTypeInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtensionTaskTypeInfo_Def.schema - TClist = [GTD("urn:vim25","ExtensionTaskTypeInfo",lazy=True)(pname=(ns,"ExtensionTaskTypeInfo"), aname="_ExtensionTaskTypeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtensionTaskTypeInfo = [] - return - Holder.__name__ = "ArrayOfExtensionTaskTypeInfo_Holder" - self.pyclass = Holder - - class ExtensionEventTypeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionEventTypeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionEventTypeInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"eventID"), aname="_eventID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeSchema"), aname="_eventTypeSchema", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionEventTypeInfo_Def.__bases__: - bases = list(ns0.ExtensionEventTypeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionEventTypeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtensionEventTypeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtensionEventTypeInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtensionEventTypeInfo_Def.schema - TClist = [GTD("urn:vim25","ExtensionEventTypeInfo",lazy=True)(pname=(ns,"ExtensionEventTypeInfo"), aname="_ExtensionEventTypeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtensionEventTypeInfo = [] - return - Holder.__name__ = "ArrayOfExtensionEventTypeInfo_Holder" - self.pyclass = Holder - - class ExtensionFaultTypeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionFaultTypeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionFaultTypeInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"faultID"), aname="_faultID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionFaultTypeInfo_Def.__bases__: - bases = list(ns0.ExtensionFaultTypeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionFaultTypeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtensionFaultTypeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtensionFaultTypeInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtensionFaultTypeInfo_Def.schema - TClist = [GTD("urn:vim25","ExtensionFaultTypeInfo",lazy=True)(pname=(ns,"ExtensionFaultTypeInfo"), aname="_ExtensionFaultTypeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtensionFaultTypeInfo = [] - return - Holder.__name__ = "ArrayOfExtensionFaultTypeInfo_Holder" - self.pyclass = Holder - - class ExtensionPrivilegeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionPrivilegeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionPrivilegeInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"privID"), aname="_privID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privGroupName"), aname="_privGroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionPrivilegeInfo_Def.__bases__: - bases = list(ns0.ExtensionPrivilegeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionPrivilegeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtensionPrivilegeInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtensionPrivilegeInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtensionPrivilegeInfo_Def.schema - TClist = [GTD("urn:vim25","ExtensionPrivilegeInfo",lazy=True)(pname=(ns,"ExtensionPrivilegeInfo"), aname="_ExtensionPrivilegeInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtensionPrivilegeInfo = [] - return - Holder.__name__ = "ArrayOfExtensionPrivilegeInfo_Holder" - self.pyclass = Holder - - class ExtensionResourceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionResourceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionResourceInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"module"), aname="_module", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"data"), aname="_data", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionResourceInfo_Def.__bases__: - bases = list(ns0.ExtensionResourceInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionResourceInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtensionResourceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtensionResourceInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtensionResourceInfo_Def.schema - TClist = [GTD("urn:vim25","ExtensionResourceInfo",lazy=True)(pname=(ns,"ExtensionResourceInfo"), aname="_ExtensionResourceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtensionResourceInfo = [] - return - Holder.__name__ = "ArrayOfExtensionResourceInfo_Holder" - self.pyclass = Holder - - class ExtensionHealthInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtensionHealthInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtensionHealthInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtensionHealthInfo_Def.__bases__: - bases = list(ns0.ExtensionHealthInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtensionHealthInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class Extension_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Extension") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Extension_Def.schema - TClist = [GTD("urn:vim25","Description",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"company"), aname="_company", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subjectName"), aname="_subjectName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionServerInfo",lazy=True)(pname=(ns,"server"), aname="_server", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionClientInfo",lazy=True)(pname=(ns,"client"), aname="_client", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionTaskTypeInfo",lazy=True)(pname=(ns,"taskList"), aname="_taskList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionEventTypeInfo",lazy=True)(pname=(ns,"eventList"), aname="_eventList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionFaultTypeInfo",lazy=True)(pname=(ns,"faultList"), aname="_faultList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionPrivilegeInfo",lazy=True)(pname=(ns,"privilegeList"), aname="_privilegeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionResourceInfo",lazy=True)(pname=(ns,"resourceList"), aname="_resourceList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastHeartbeatTime"), aname="_lastHeartbeatTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtensionHealthInfo",lazy=True)(pname=(ns,"healthInfo"), aname="_healthInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.Extension_Def.__bases__: - bases = list(ns0.Extension_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.Extension_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtension_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtension") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtension_Def.schema - TClist = [GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"Extension"), aname="_Extension", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._Extension = [] - return - Holder.__name__ = "ArrayOfExtension_Holder" - self.pyclass = Holder - - class UnregisterExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UnregisterExtensionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UnregisterExtensionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._extensionKey = None - return - Holder.__name__ = "UnregisterExtensionRequestType_Holder" - self.pyclass = Holder - - class FindExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindExtensionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindExtensionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._extensionKey = None - return - Holder.__name__ = "FindExtensionRequestType_Holder" - self.pyclass = Holder - - class RegisterExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RegisterExtensionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RegisterExtensionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"extension"), aname="_extension", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._extension = None - return - Holder.__name__ = "RegisterExtensionRequestType_Holder" - self.pyclass = Holder - - class UpdateExtensionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateExtensionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateExtensionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"extension"), aname="_extension", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._extension = None - return - Holder.__name__ = "UpdateExtensionRequestType_Holder" - self.pyclass = Holder - - class GetPublicKeyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "GetPublicKeyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.GetPublicKeyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "GetPublicKeyRequestType_Holder" - self.pyclass = Holder - - class SetPublicKeyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetPublicKeyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetPublicKeyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"publicKey"), aname="_publicKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._extensionKey = None - self._publicKey = None - return - Holder.__name__ = "SetPublicKeyRequestType_Holder" - self.pyclass = Holder - - class MoveDatastoreFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MoveDatastoreFileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MoveDatastoreFileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destinationName"), aname="_destinationName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destinationDatacenter"), aname="_destinationDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._sourceName = None - self._sourceDatacenter = None - self._destinationName = None - self._destinationDatacenter = None - self._force = None - return - Holder.__name__ = "MoveDatastoreFileRequestType_Holder" - self.pyclass = Holder - - class CopyDatastoreFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CopyDatastoreFileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CopyDatastoreFileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destinationName"), aname="_destinationName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destinationDatacenter"), aname="_destinationDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._sourceName = None - self._sourceDatacenter = None - self._destinationName = None - self._destinationDatacenter = None - self._force = None - return - Holder.__name__ = "CopyDatastoreFileRequestType_Holder" - self.pyclass = Holder - - class DeleteDatastoreFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DeleteDatastoreFileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DeleteDatastoreFileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "DeleteDatastoreFileRequestType_Holder" - self.pyclass = Holder - - class MakeDirectoryRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MakeDirectoryRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MakeDirectoryRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"createParentDirectories"), aname="_createParentDirectories", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - self._createParentDirectories = None - return - Holder.__name__ = "MakeDirectoryRequestType_Holder" - self.pyclass = Holder - - class ChangeOwnerRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ChangeOwnerRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ChangeOwnerRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"owner"), aname="_owner", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - self._owner = None - return - Holder.__name__ = "ChangeOwnerRequestType_Holder" - self.pyclass = Holder - - class CreateFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateFolderRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateFolderRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - return - Holder.__name__ = "CreateFolderRequestType_Holder" - self.pyclass = Holder - - class MoveIntoFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MoveIntoFolderRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MoveIntoFolderRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"list"), aname="_list", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._list = [] - return - Holder.__name__ = "MoveIntoFolderRequestType_Holder" - self.pyclass = Holder - - class CreateVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - self._pool = None - self._host = None - return - Holder.__name__ = "CreateVMRequestType_Holder" - self.pyclass = Holder - - class RegisterVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RegisterVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RegisterVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"asTemplate"), aname="_asTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._path = None - self._name = None - self._asTemplate = None - self._pool = None - self._host = None - return - Holder.__name__ = "RegisterVMRequestType_Holder" - self.pyclass = Holder - - class CreateClusterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateClusterRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateClusterRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._spec = None - return - Holder.__name__ = "CreateClusterRequestType_Holder" - self.pyclass = Holder - - class CreateClusterExRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateClusterExRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateClusterExRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterConfigSpecEx",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._spec = None - return - Holder.__name__ = "CreateClusterExRequestType_Holder" - self.pyclass = Holder - - class AddStandaloneHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddStandaloneHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddStandaloneHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComputeResourceConfigSpec",lazy=True)(pname=(ns,"compResSpec"), aname="_compResSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"addConnected"), aname="_addConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - self._compResSpec = None - self._addConnected = None - self._license = None - return - Holder.__name__ = "AddStandaloneHostRequestType_Holder" - self.pyclass = Holder - - class CreateDatacenterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateDatacenterRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateDatacenterRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - return - Holder.__name__ = "CreateDatacenterRequestType_Holder" - self.pyclass = Holder - - class UnregisterAndDestroyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UnregisterAndDestroyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UnregisterAndDestroyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "UnregisterAndDestroyRequestType_Holder" - self.pyclass = Holder - - class FolderCreateDVSRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FolderCreateDVSRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FolderCreateDVSRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "FolderCreateDVSRequestType_Holder" - self.pyclass = Holder - - class SetCollectorPageSizeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetCollectorPageSizeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetCollectorPageSizeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._maxCount = None - return - Holder.__name__ = "SetCollectorPageSizeRequestType_Holder" - self.pyclass = Holder - - class RewindCollectorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RewindCollectorRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RewindCollectorRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RewindCollectorRequestType_Holder" - self.pyclass = Holder - - class ResetCollectorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetCollectorRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetCollectorRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ResetCollectorRequestType_Holder" - self.pyclass = Holder - - class DestroyCollectorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyCollectorRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyCollectorRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DestroyCollectorRequestType_Holder" - self.pyclass = Holder - - class HostServiceTicket_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostServiceTicket") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostServiceTicket_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"service"), aname="_service", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"serviceVersion"), aname="_serviceVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostServiceTicket_Def.__bases__: - bases = list(ns0.HostServiceTicket_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostServiceTicket_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostSystemConnectionState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostSystemConnectionState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostSystemPowerState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostSystemPowerState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class QueryHostConnectionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryHostConnectionInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryHostConnectionInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryHostConnectionInfoRequestType_Holder" - self.pyclass = Holder - - class UpdateSystemResourcesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateSystemResourcesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateSystemResourcesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"resourceInfo"), aname="_resourceInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._resourceInfo = None - return - Holder.__name__ = "UpdateSystemResourcesRequestType_Holder" - self.pyclass = Holder - - class ReconnectHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconnectHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconnectHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectSpec",lazy=True)(pname=(ns,"cnxSpec"), aname="_cnxSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._cnxSpec = None - return - Holder.__name__ = "ReconnectHostRequestType_Holder" - self.pyclass = Holder - - class DisconnectHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DisconnectHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DisconnectHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DisconnectHostRequestType_Holder" - self.pyclass = Holder - - class EnterMaintenanceModeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EnterMaintenanceModeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.EnterMaintenanceModeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"evacuatePoweredOffVms"), aname="_evacuatePoweredOffVms", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._timeout = None - self._evacuatePoweredOffVms = None - return - Holder.__name__ = "EnterMaintenanceModeRequestType_Holder" - self.pyclass = Holder - - class ExitMaintenanceModeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExitMaintenanceModeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExitMaintenanceModeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._timeout = None - return - Holder.__name__ = "ExitMaintenanceModeRequestType_Holder" - self.pyclass = Holder - - class RebootHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RebootHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RebootHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._force = None - return - Holder.__name__ = "RebootHostRequestType_Holder" - self.pyclass = Holder - - class ShutdownHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ShutdownHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ShutdownHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._force = None - return - Holder.__name__ = "ShutdownHostRequestType_Holder" - self.pyclass = Holder - - class PowerDownHostToStandByRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PowerDownHostToStandByRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PowerDownHostToStandByRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeoutSec"), aname="_timeoutSec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"evacuatePoweredOffVms"), aname="_evacuatePoweredOffVms", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._timeoutSec = None - self._evacuatePoweredOffVms = None - return - Holder.__name__ = "PowerDownHostToStandByRequestType_Holder" - self.pyclass = Holder - - class PowerUpHostFromStandByRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PowerUpHostFromStandByRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PowerUpHostFromStandByRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeoutSec"), aname="_timeoutSec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._timeoutSec = None - return - Holder.__name__ = "PowerUpHostFromStandByRequestType_Holder" - self.pyclass = Holder - - class QueryMemoryOverheadRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryMemoryOverheadRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryMemoryOverheadRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memorySize"), aname="_memorySize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"videoRamSize"), aname="_videoRamSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVcpus"), aname="_numVcpus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._memorySize = None - self._videoRamSize = None - self._numVcpus = None - return - Holder.__name__ = "QueryMemoryOverheadRequestType_Holder" - self.pyclass = Holder - - class QueryMemoryOverheadExRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryMemoryOverheadExRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryMemoryOverheadExRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigInfo",lazy=True)(pname=(ns,"vmConfigInfo"), aname="_vmConfigInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vmConfigInfo = None - return - Holder.__name__ = "QueryMemoryOverheadExRequestType_Holder" - self.pyclass = Holder - - class ReconfigureHostForDASRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureHostForDASRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureHostForDASRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ReconfigureHostForDASRequestType_Holder" - self.pyclass = Holder - - class UpdateFlagsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateFlagsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateFlagsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFlagInfo",lazy=True)(pname=(ns,"flagInfo"), aname="_flagInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._flagInfo = None - return - Holder.__name__ = "UpdateFlagsRequestType_Holder" - self.pyclass = Holder - - class AcquireCimServicesTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AcquireCimServicesTicketRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AcquireCimServicesTicketRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "AcquireCimServicesTicketRequestType_Holder" - self.pyclass = Holder - - class UpdateIpmiRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateIpmiRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateIpmiRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpmiInfo",lazy=True)(pname=(ns,"ipmiInfo"), aname="_ipmiInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._ipmiInfo = None - return - Holder.__name__ = "UpdateIpmiRequestType_Holder" - self.pyclass = Holder - - class HttpNfcLeaseState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HttpNfcLeaseState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HttpNfcLeaseInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HttpNfcLeaseInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HttpNfcLeaseInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"lease"), aname="_lease", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HttpNfcLeaseDeviceUrl",lazy=True)(pname=(ns,"deviceUrl"), aname="_deviceUrl", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"totalDiskCapacityInKB"), aname="_totalDiskCapacityInKB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"leaseTimeout"), aname="_leaseTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HttpNfcLeaseInfo_Def.__bases__: - bases = list(ns0.HttpNfcLeaseInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HttpNfcLeaseInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HttpNfcLeaseDeviceUrl_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HttpNfcLeaseDeviceUrl") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HttpNfcLeaseDeviceUrl_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"importKey"), aname="_importKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HttpNfcLeaseDeviceUrl_Def.__bases__: - bases = list(ns0.HttpNfcLeaseDeviceUrl_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HttpNfcLeaseDeviceUrl_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHttpNfcLeaseDeviceUrl_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHttpNfcLeaseDeviceUrl") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHttpNfcLeaseDeviceUrl_Def.schema - TClist = [GTD("urn:vim25","HttpNfcLeaseDeviceUrl",lazy=True)(pname=(ns,"HttpNfcLeaseDeviceUrl"), aname="_HttpNfcLeaseDeviceUrl", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HttpNfcLeaseDeviceUrl = [] - return - Holder.__name__ = "ArrayOfHttpNfcLeaseDeviceUrl_Holder" - self.pyclass = Holder - - class HttpNfcLeaseCompleteRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HttpNfcLeaseCompleteRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HttpNfcLeaseCompleteRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "HttpNfcLeaseCompleteRequestType_Holder" - self.pyclass = Holder - - class HttpNfcLeaseAbortRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HttpNfcLeaseAbortRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HttpNfcLeaseAbortRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._fault = None - return - Holder.__name__ = "HttpNfcLeaseAbortRequestType_Holder" - self.pyclass = Holder - - class HttpNfcLeaseProgressRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HttpNfcLeaseProgressRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HttpNfcLeaseProgressRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"percent"), aname="_percent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._percent = None - return - Holder.__name__ = "HttpNfcLeaseProgressRequestType_Holder" - self.pyclass = Holder - - class ImportSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ImportSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ImportSpec_Def.schema - TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"entityConfig"), aname="_entityConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ImportSpec_Def.__bases__: - bases = list(ns0.ImportSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ImportSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfImportSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfImportSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfImportSpec_Def.schema - TClist = [GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"ImportSpec"), aname="_ImportSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ImportSpec = [] - return - Holder.__name__ = "ArrayOfImportSpec_Holder" - self.pyclass = Holder - - class InheritablePolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InheritablePolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InheritablePolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"inherited"), aname="_inherited", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.InheritablePolicy_Def.__bases__: - bases = list(ns0.InheritablePolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.InheritablePolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IntPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IntPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IntPolicy_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.IntPolicy_Def.__bases__: - bases = list(ns0.IntPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.IntPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class QueryIpPoolsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryIpPoolsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryIpPoolsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dc = None - return - Holder.__name__ = "QueryIpPoolsRequestType_Holder" - self.pyclass = Holder - - class CreateIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateIpPoolRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateIpPoolRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dc = None - self._pool = None - return - Holder.__name__ = "CreateIpPoolRequestType_Holder" - self.pyclass = Holder - - class UpdateIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateIpPoolRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateIpPoolRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dc = None - self._pool = None - return - Holder.__name__ = "UpdateIpPoolRequestType_Holder" - self.pyclass = Holder - - class DestroyIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyIpPoolRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyIpPoolRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dc = None - self._id = None - self._force = None - return - Holder.__name__ = "DestroyIpPoolRequestType_Holder" - self.pyclass = Holder - - class AssociateIpPoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AssociateIpPoolRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AssociateIpPoolRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dc"), aname="_dc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"net"), aname="_net", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"poolId"), aname="_poolId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dc = None - self._net = None - self._poolId = None - return - Holder.__name__ = "AssociateIpPoolRequestType_Holder" - self.pyclass = Holder - - class KeyValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "KeyValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.KeyValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.KeyValue_Def.__bases__: - bases = list(ns0.KeyValue_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.KeyValue_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfKeyValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfKeyValue") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfKeyValue_Def.schema - TClist = [GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"KeyValue"), aname="_KeyValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._KeyValue = [] - return - Holder.__name__ = "ArrayOfKeyValue_Holder" - self.pyclass = Holder - - class LicenseAssignmentManagerLicenseAssignment_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseAssignmentManagerLicenseAssignment") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseAssignmentManagerLicenseAssignment_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityDisplayName"), aname="_entityDisplayName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"assignedLicense"), aname="_assignedLicense", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"properties"), aname="_properties", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseAssignmentManagerLicenseAssignment_Def.__bases__: - bases = list(ns0.LicenseAssignmentManagerLicenseAssignment_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseAssignmentManagerLicenseAssignment_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLicenseAssignmentManagerLicenseAssignment_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLicenseAssignmentManagerLicenseAssignment") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLicenseAssignmentManagerLicenseAssignment_Def.schema - TClist = [GTD("urn:vim25","LicenseAssignmentManagerLicenseAssignment",lazy=True)(pname=(ns,"LicenseAssignmentManagerLicenseAssignment"), aname="_LicenseAssignmentManagerLicenseAssignment", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LicenseAssignmentManagerLicenseAssignment = [] - return - Holder.__name__ = "ArrayOfLicenseAssignmentManagerLicenseAssignment_Holder" - self.pyclass = Holder - - class LicenseAssignmentManagerEntityFeaturePair_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseAssignmentManagerEntityFeaturePair") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseAssignmentManagerEntityFeaturePair_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseAssignmentManagerEntityFeaturePair_Def.__bases__: - bases = list(ns0.LicenseAssignmentManagerEntityFeaturePair_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseAssignmentManagerEntityFeaturePair_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLicenseAssignmentManagerEntityFeaturePair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLicenseAssignmentManagerEntityFeaturePair") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLicenseAssignmentManagerEntityFeaturePair_Def.schema - TClist = [GTD("urn:vim25","LicenseAssignmentManagerEntityFeaturePair",lazy=True)(pname=(ns,"LicenseAssignmentManagerEntityFeaturePair"), aname="_LicenseAssignmentManagerEntityFeaturePair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LicenseAssignmentManagerEntityFeaturePair = [] - return - Holder.__name__ = "ArrayOfLicenseAssignmentManagerEntityFeaturePair_Holder" - self.pyclass = Holder - - class LicenseAssignmentManagerFeatureLicenseAvailability_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseAssignmentManagerFeatureLicenseAvailability") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.schema - TClist = [GTD("urn:vim25","LicenseAssignmentManagerEntityFeaturePair",lazy=True)(pname=(ns,"entityFeature"), aname="_entityFeature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"licensed"), aname="_licensed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.__bases__: - bases = list(ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseAssignmentManagerFeatureLicenseAvailability_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability_Def.schema - TClist = [GTD("urn:vim25","LicenseAssignmentManagerFeatureLicenseAvailability",lazy=True)(pname=(ns,"LicenseAssignmentManagerFeatureLicenseAvailability"), aname="_LicenseAssignmentManagerFeatureLicenseAvailability", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LicenseAssignmentManagerFeatureLicenseAvailability = [] - return - Holder.__name__ = "ArrayOfLicenseAssignmentManagerFeatureLicenseAvailability_Holder" - self.pyclass = Holder - - class UpdateAssignedLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateAssignedLicenseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateAssignedLicenseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityDisplayName"), aname="_entityDisplayName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._licenseKey = None - self._entityDisplayName = None - return - Holder.__name__ = "UpdateAssignedLicenseRequestType_Holder" - self.pyclass = Holder - - class RemoveAssignedLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveAssignedLicenseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveAssignedLicenseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entityId = None - return - Holder.__name__ = "RemoveAssignedLicenseRequestType_Holder" - self.pyclass = Holder - - class QueryAssignedLicensesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryAssignedLicensesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryAssignedLicensesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entityId = None - return - Holder.__name__ = "QueryAssignedLicensesRequestType_Holder" - self.pyclass = Holder - - class IsFeatureAvailableRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "IsFeatureAvailableRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.IsFeatureAvailableRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseAssignmentManagerEntityFeaturePair",lazy=True)(pname=(ns,"entityFeaturePair"), aname="_entityFeaturePair", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entityFeaturePair = [] - return - Holder.__name__ = "IsFeatureAvailableRequestType_Holder" - self.pyclass = Holder - - class SetFeatureInUseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetFeatureInUseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetFeatureInUseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entityId = None - self._feature = None - return - Holder.__name__ = "SetFeatureInUseRequestType_Holder" - self.pyclass = Holder - - class ResetFeatureInUseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetFeatureInUseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetFeatureInUseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entityId = None - self._feature = None - return - Holder.__name__ = "ResetFeatureInUseRequestType_Holder" - self.pyclass = Holder - - class LicenseManagerState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LicenseManagerState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LicenseManagerLicenseKey_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LicenseManagerLicenseKey") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LicenseSource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseSource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseSource_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseSource_Def.__bases__: - bases = list(ns0.LicenseSource_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseSource_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseServerSource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseServerSource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseServerSource_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseSource_Def not in ns0.LicenseServerSource_Def.__bases__: - bases = list(ns0.LicenseServerSource_Def.__bases__) - bases.insert(0, ns0.LicenseSource_Def) - ns0.LicenseServerSource_Def.__bases__ = tuple(bases) - - ns0.LicenseSource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LocalLicenseSource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LocalLicenseSource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LocalLicenseSource_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseKeys"), aname="_licenseKeys", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseSource_Def not in ns0.LocalLicenseSource_Def.__bases__: - bases = list(ns0.LocalLicenseSource_Def.__bases__) - bases.insert(0, ns0.LicenseSource_Def) - ns0.LocalLicenseSource_Def.__bases__ = tuple(bases) - - ns0.LicenseSource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EvaluationLicenseSource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EvaluationLicenseSource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EvaluationLicenseSource_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"remainingHours"), aname="_remainingHours", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseSource_Def not in ns0.EvaluationLicenseSource_Def.__bases__: - bases = list(ns0.EvaluationLicenseSource_Def.__bases__) - bases.insert(0, ns0.LicenseSource_Def) - ns0.EvaluationLicenseSource_Def.__bases__ = tuple(bases) - - ns0.LicenseSource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseFeatureInfoUnit_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LicenseFeatureInfoUnit") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LicenseFeatureInfoState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LicenseFeatureInfoState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LicenseFeatureInfoSourceRestriction_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LicenseFeatureInfoSourceRestriction") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LicenseFeatureInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseFeatureInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseFeatureInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureName"), aname="_featureName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureDescription"), aname="_featureDescription", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseFeatureInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"costUnit"), aname="_costUnit", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceRestriction"), aname="_sourceRestriction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dependentKey"), aname="_dependentKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"edition"), aname="_edition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"expiresOn"), aname="_expiresOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseFeatureInfo_Def.__bases__: - bases = list(ns0.LicenseFeatureInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseFeatureInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLicenseFeatureInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLicenseFeatureInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLicenseFeatureInfo_Def.schema - TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"LicenseFeatureInfo"), aname="_LicenseFeatureInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LicenseFeatureInfo = [] - return - Holder.__name__ = "ArrayOfLicenseFeatureInfo_Holder" - self.pyclass = Holder - - class LicenseReservationInfoState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LicenseReservationInfoState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LicenseReservationInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseReservationInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseReservationInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseReservationInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"required"), aname="_required", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseReservationInfo_Def.__bases__: - bases = list(ns0.LicenseReservationInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseReservationInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLicenseReservationInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLicenseReservationInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLicenseReservationInfo_Def.schema - TClist = [GTD("urn:vim25","LicenseReservationInfo",lazy=True)(pname=(ns,"LicenseReservationInfo"), aname="_LicenseReservationInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LicenseReservationInfo = [] - return - Holder.__name__ = "ArrayOfLicenseReservationInfo_Holder" - self.pyclass = Holder - - class LicenseAvailabilityInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseAvailabilityInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseAvailabilityInfo_Def.schema - TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"total"), aname="_total", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseAvailabilityInfo_Def.__bases__: - bases = list(ns0.LicenseAvailabilityInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseAvailabilityInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLicenseAvailabilityInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLicenseAvailabilityInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLicenseAvailabilityInfo_Def.schema - TClist = [GTD("urn:vim25","LicenseAvailabilityInfo",lazy=True)(pname=(ns,"LicenseAvailabilityInfo"), aname="_LicenseAvailabilityInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LicenseAvailabilityInfo = [] - return - Holder.__name__ = "ArrayOfLicenseAvailabilityInfo_Holder" - self.pyclass = Holder - - class LicenseDiagnostics_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseDiagnostics") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseDiagnostics_Def.schema - TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"sourceLastChanged"), aname="_sourceLastChanged", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceLost"), aname="_sourceLost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"sourceLatency"), aname="_sourceLatency", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseRequests"), aname="_licenseRequests", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseRequestFailures"), aname="_licenseRequestFailures", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseFeatureUnknowns"), aname="_licenseFeatureUnknowns", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseManagerState",lazy=True)(pname=(ns,"opState"), aname="_opState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastStatusUpdate"), aname="_lastStatusUpdate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"opFailureMessage"), aname="_opFailureMessage", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseDiagnostics_Def.__bases__: - bases = list(ns0.LicenseDiagnostics_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseDiagnostics_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseUsageInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseUsageInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseUsageInfo_Def.schema - TClist = [GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sourceAvailable"), aname="_sourceAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseReservationInfo",lazy=True)(pname=(ns,"reservationInfo"), aname="_reservationInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"featureInfo"), aname="_featureInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseUsageInfo_Def.__bases__: - bases = list(ns0.LicenseUsageInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseUsageInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseManagerEvaluationInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseManagerEvaluationInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseManagerEvaluationInfo_Def.schema - TClist = [GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"properties"), aname="_properties", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseManagerEvaluationInfo_Def.__bases__: - bases = list(ns0.LicenseManagerEvaluationInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseManagerEvaluationInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseManagerLicenseInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseManagerLicenseInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseManagerLicenseInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"editionKey"), aname="_editionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"total"), aname="_total", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"used"), aname="_used", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"costUnit"), aname="_costUnit", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"properties"), aname="_properties", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"labels"), aname="_labels", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LicenseManagerLicenseInfo_Def.__bases__: - bases = list(ns0.LicenseManagerLicenseInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LicenseManagerLicenseInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLicenseManagerLicenseInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLicenseManagerLicenseInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLicenseManagerLicenseInfo_Def.schema - TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"LicenseManagerLicenseInfo"), aname="_LicenseManagerLicenseInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LicenseManagerLicenseInfo = [] - return - Holder.__name__ = "ArrayOfLicenseManagerLicenseInfo_Holder" - self.pyclass = Holder - - class QuerySupportedFeaturesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QuerySupportedFeaturesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QuerySupportedFeaturesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "QuerySupportedFeaturesRequestType_Holder" - self.pyclass = Holder - - class QueryLicenseSourceAvailabilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryLicenseSourceAvailabilityRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryLicenseSourceAvailabilityRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "QueryLicenseSourceAvailabilityRequestType_Holder" - self.pyclass = Holder - - class QueryLicenseUsageRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryLicenseUsageRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryLicenseUsageRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "QueryLicenseUsageRequestType_Holder" - self.pyclass = Holder - - class SetLicenseEditionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetLicenseEditionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetLicenseEditionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._featureKey = None - return - Holder.__name__ = "SetLicenseEditionRequestType_Holder" - self.pyclass = Holder - - class CheckLicenseFeatureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckLicenseFeatureRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckLicenseFeatureRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._featureKey = None - return - Holder.__name__ = "CheckLicenseFeatureRequestType_Holder" - self.pyclass = Holder - - class EnableFeatureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EnableFeatureRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.EnableFeatureRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._featureKey = None - return - Holder.__name__ = "EnableFeatureRequestType_Holder" - self.pyclass = Holder - - class DisableFeatureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DisableFeatureRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DisableFeatureRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"featureKey"), aname="_featureKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._featureKey = None - return - Holder.__name__ = "DisableFeatureRequestType_Holder" - self.pyclass = Holder - - class ConfigureLicenseSourceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ConfigureLicenseSourceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ConfigureLicenseSourceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"licenseSource"), aname="_licenseSource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._licenseSource = None - return - Holder.__name__ = "ConfigureLicenseSourceRequestType_Holder" - self.pyclass = Holder - - class UpdateLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateLicenseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateLicenseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"labels"), aname="_labels", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._licenseKey = None - self._labels = [] - return - Holder.__name__ = "UpdateLicenseRequestType_Holder" - self.pyclass = Holder - - class AddLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddLicenseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddLicenseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"labels"), aname="_labels", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._licenseKey = None - self._labels = [] - return - Holder.__name__ = "AddLicenseRequestType_Holder" - self.pyclass = Holder - - class RemoveLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveLicenseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveLicenseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._licenseKey = None - return - Holder.__name__ = "RemoveLicenseRequestType_Holder" - self.pyclass = Holder - - class DecodeLicenseRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DecodeLicenseRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DecodeLicenseRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._licenseKey = None - return - Holder.__name__ = "DecodeLicenseRequestType_Holder" - self.pyclass = Holder - - class UpdateLicenseLabelRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateLicenseLabelRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateLicenseLabelRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"labelKey"), aname="_labelKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"labelValue"), aname="_labelValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._licenseKey = None - self._labelKey = None - self._labelValue = None - return - Holder.__name__ = "UpdateLicenseLabelRequestType_Holder" - self.pyclass = Holder - - class RemoveLicenseLabelRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveLicenseLabelRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveLicenseLabelRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"labelKey"), aname="_labelKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._licenseKey = None - self._labelKey = None - return - Holder.__name__ = "RemoveLicenseLabelRequestType_Holder" - self.pyclass = Holder - - class LocalizationManagerMessageCatalog_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LocalizationManagerMessageCatalog") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LocalizationManagerMessageCatalog_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"moduleName"), aname="_moduleName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"catalogName"), aname="_catalogName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"catalogUri"), aname="_catalogUri", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModified"), aname="_lastModified", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"md5sum"), aname="_md5sum", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LocalizationManagerMessageCatalog_Def.__bases__: - bases = list(ns0.LocalizationManagerMessageCatalog_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LocalizationManagerMessageCatalog_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfLocalizationManagerMessageCatalog_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLocalizationManagerMessageCatalog") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLocalizationManagerMessageCatalog_Def.schema - TClist = [GTD("urn:vim25","LocalizationManagerMessageCatalog",lazy=True)(pname=(ns,"LocalizationManagerMessageCatalog"), aname="_LocalizationManagerMessageCatalog", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._LocalizationManagerMessageCatalog = [] - return - Holder.__name__ = "ArrayOfLocalizationManagerMessageCatalog_Holder" - self.pyclass = Holder - - class LongPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LongPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LongPolicy_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.LongPolicy_Def.__bases__: - bases = list(ns0.LongPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.LongPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ManagedEntityStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ManagedEntityStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ReloadRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReloadRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReloadRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ReloadRequestType_Holder" - self.pyclass = Holder - - class RenameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RenameRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RenameRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._newName = None - return - Holder.__name__ = "RenameRequestType_Holder" - self.pyclass = Holder - - class DestroyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DestroyRequestType_Holder" - self.pyclass = Holder - - class MethodDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MethodDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MethodDescription_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Description_Def not in ns0.MethodDescription_Def.__bases__: - bases = list(ns0.MethodDescription_Def.__bases__) - bases.insert(0, ns0.Description_Def) - ns0.MethodDescription_Def.__bases__ = tuple(bases) - - ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NetworkSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworkSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworkSummary_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"accessible"), aname="_accessible", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipPoolName"), aname="_ipPoolName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.NetworkSummary_Def.__bases__: - bases = list(ns0.NetworkSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.NetworkSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DestroyNetworkRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyNetworkRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyNetworkRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DestroyNetworkRequestType_Holder" - self.pyclass = Holder - - class NumericRange_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NumericRange") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NumericRange_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"start"), aname="_start", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"end"), aname="_end", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.NumericRange_Def.__bases__: - bases = list(ns0.NumericRange_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.NumericRange_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfNumericRange_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfNumericRange") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfNumericRange_Def.schema - TClist = [GTD("urn:vim25","NumericRange",lazy=True)(pname=(ns,"NumericRange"), aname="_NumericRange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._NumericRange = [] - return - Holder.__name__ = "ArrayOfNumericRange_Holder" - self.pyclass = Holder - - class OvfDeploymentOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfDeploymentOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfDeploymentOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfDeploymentOption_Def.__bases__: - bases = list(ns0.OvfDeploymentOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfDeploymentOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOvfDeploymentOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOvfDeploymentOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOvfDeploymentOption_Def.schema - TClist = [GTD("urn:vim25","OvfDeploymentOption",lazy=True)(pname=(ns,"OvfDeploymentOption"), aname="_OvfDeploymentOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OvfDeploymentOption = [] - return - Holder.__name__ = "ArrayOfOvfDeploymentOption_Holder" - self.pyclass = Holder - - class OvfManagerCommonParams_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfManagerCommonParams") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfManagerCommonParams_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deploymentOption"), aname="_deploymentOption", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"msgBundle"), aname="_msgBundle", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfManagerCommonParams_Def.__bases__: - bases = list(ns0.OvfManagerCommonParams_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfManagerCommonParams_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfValidateHostParams_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfValidateHostParams") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfValidateHostParams_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfManagerCommonParams_Def not in ns0.OvfValidateHostParams_Def.__bases__: - bases = list(ns0.OvfValidateHostParams_Def.__bases__) - bases.insert(0, ns0.OvfManagerCommonParams_Def) - ns0.OvfValidateHostParams_Def.__bases__ = tuple(bases) - - ns0.OvfManagerCommonParams_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfValidateHostResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfValidateHostResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfValidateHostResult_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"downloadSize"), aname="_downloadSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"flatDeploymentSize"), aname="_flatDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"sparseDeploymentSize"), aname="_sparseDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfValidateHostResult_Def.__bases__: - bases = list(ns0.OvfValidateHostResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfValidateHostResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfParseDescriptorParams_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfParseDescriptorParams") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfParseDescriptorParams_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfManagerCommonParams_Def not in ns0.OvfParseDescriptorParams_Def.__bases__: - bases = list(ns0.OvfParseDescriptorParams_Def.__bases__) - bases.insert(0, ns0.OvfManagerCommonParams_Def) - ns0.OvfParseDescriptorParams_Def.__bases__ = tuple(bases) - - ns0.OvfManagerCommonParams_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfParseDescriptorResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfParseDescriptorResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfParseDescriptorResult_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"eula"), aname="_eula", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAllocationScheme"), aname="_ipAllocationScheme", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipProtocols"), aname="_ipProtocols", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"approximateDownloadSize"), aname="_approximateDownloadSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"approximateFlatDeploymentSize"), aname="_approximateFlatDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"approximateSparseDeploymentSize"), aname="_approximateSparseDeploymentSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultEntityName"), aname="_defaultEntityName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"virtualApp"), aname="_virtualApp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfDeploymentOption",lazy=True)(pname=(ns,"deploymentOption"), aname="_deploymentOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultDeploymentOption"), aname="_defaultDeploymentOption", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfParseDescriptorResult_Def.__bases__: - bases = list(ns0.OvfParseDescriptorResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfParseDescriptorResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfNetworkInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfNetworkInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfNetworkInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfNetworkInfo_Def.__bases__: - bases = list(ns0.OvfNetworkInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfNetworkInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOvfNetworkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOvfNetworkInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOvfNetworkInfo_Def.schema - TClist = [GTD("urn:vim25","OvfNetworkInfo",lazy=True)(pname=(ns,"OvfNetworkInfo"), aname="_OvfNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OvfNetworkInfo = [] - return - Holder.__name__ = "ArrayOfOvfNetworkInfo_Holder" - self.pyclass = Holder - - class OvfCreateImportSpecParams_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfCreateImportSpecParams") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfCreateImportSpecParams_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hostSystem"), aname="_hostSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfNetworkMapping",lazy=True)(pname=(ns,"networkMapping"), aname="_networkMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAllocationPolicy"), aname="_ipAllocationPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipProtocol"), aname="_ipProtocol", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"propertyMapping"), aname="_propertyMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfManagerCommonParams_Def not in ns0.OvfCreateImportSpecParams_Def.__bases__: - bases = list(ns0.OvfCreateImportSpecParams_Def.__bases__) - bases.insert(0, ns0.OvfManagerCommonParams_Def) - ns0.OvfCreateImportSpecParams_Def.__bases__ = tuple(bases) - - ns0.OvfManagerCommonParams_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfNetworkMapping_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfNetworkMapping") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfNetworkMapping_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfNetworkMapping_Def.__bases__: - bases = list(ns0.OvfNetworkMapping_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfNetworkMapping_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOvfNetworkMapping_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOvfNetworkMapping") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOvfNetworkMapping_Def.schema - TClist = [GTD("urn:vim25","OvfNetworkMapping",lazy=True)(pname=(ns,"OvfNetworkMapping"), aname="_OvfNetworkMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OvfNetworkMapping = [] - return - Holder.__name__ = "ArrayOfOvfNetworkMapping_Holder" - self.pyclass = Holder - - class OvfCreateImportSpecResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfCreateImportSpecResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfCreateImportSpecResult_Def.schema - TClist = [GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"importSpec"), aname="_importSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfFileItem",lazy=True)(pname=(ns,"fileItem"), aname="_fileItem", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfCreateImportSpecResult_Def.__bases__: - bases = list(ns0.OvfCreateImportSpecResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfCreateImportSpecResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfFileItem_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfFileItem") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfFileItem_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compressionMethod"), aname="_compressionMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"chunkSize"), aname="_chunkSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cimType"), aname="_cimType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"create"), aname="_create", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfFileItem_Def.__bases__: - bases = list(ns0.OvfFileItem_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfFileItem_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOvfFileItem_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOvfFileItem") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOvfFileItem_Def.schema - TClist = [GTD("urn:vim25","OvfFileItem",lazy=True)(pname=(ns,"OvfFileItem"), aname="_OvfFileItem", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OvfFileItem = [] - return - Holder.__name__ = "ArrayOfOvfFileItem_Holder" - self.pyclass = Holder - - class OvfCreateDescriptorParams_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfCreateDescriptorParams") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfCreateDescriptorParams_Def.schema - TClist = [GTD("urn:vim25","OvfFile",lazy=True)(pname=(ns,"ovfFiles"), aname="_ovfFiles", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfCreateDescriptorParams_Def.__bases__: - bases = list(ns0.OvfCreateDescriptorParams_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfCreateDescriptorParams_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfCreateDescriptorResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfCreateDescriptorResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfCreateDescriptorResult_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfCreateDescriptorResult_Def.__bases__: - bases = list(ns0.OvfCreateDescriptorResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfCreateDescriptorResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfFile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfFile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfFile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compressionMethod"), aname="_compressionMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"chunkSize"), aname="_chunkSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OvfFile_Def.__bases__: - bases = list(ns0.OvfFile_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OvfFile_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOvfFile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOvfFile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOvfFile_Def.schema - TClist = [GTD("urn:vim25","OvfFile",lazy=True)(pname=(ns,"OvfFile"), aname="_OvfFile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OvfFile = [] - return - Holder.__name__ = "ArrayOfOvfFile_Holder" - self.pyclass = Holder - - class ValidateHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ValidateHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ValidateHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfValidateHostParams",lazy=True)(pname=(ns,"vhp"), aname="_vhp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._ovfDescriptor = None - self._host = None - self._vhp = None - return - Holder.__name__ = "ValidateHostRequestType_Holder" - self.pyclass = Holder - - class ParseDescriptorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ParseDescriptorRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ParseDescriptorRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfParseDescriptorParams",lazy=True)(pname=(ns,"pdp"), aname="_pdp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._ovfDescriptor = None - self._pdp = None - return - Holder.__name__ = "ParseDescriptorRequestType_Holder" - self.pyclass = Holder - - class CreateImportSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateImportSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateImportSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescriptor"), aname="_ovfDescriptor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfCreateImportSpecParams",lazy=True)(pname=(ns,"cisp"), aname="_cisp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._ovfDescriptor = None - self._resourcePool = None - self._datastore = None - self._cisp = None - return - Holder.__name__ = "CreateImportSpecRequestType_Holder" - self.pyclass = Holder - - class CreateDescriptorRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateDescriptorRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateDescriptorRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OvfCreateDescriptorParams",lazy=True)(pname=(ns,"cdp"), aname="_cdp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._obj = None - self._cdp = None - return - Holder.__name__ = "CreateDescriptorRequestType_Holder" - self.pyclass = Holder - - class PasswordField_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PasswordField") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PasswordField_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PasswordField_Def.__bases__: - bases = list(ns0.PasswordField_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PasswordField_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PerformanceDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerformanceDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerformanceDescription_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"counterType"), aname="_counterType", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"statsType"), aname="_statsType", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerformanceDescription_Def.__bases__: - bases = list(ns0.PerformanceDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerformanceDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PerfFormat_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PerfFormat") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class PerfProviderSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfProviderSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfProviderSummary_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"currentSupported"), aname="_currentSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"summarySupported"), aname="_summarySupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"refreshRate"), aname="_refreshRate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfProviderSummary_Def.__bases__: - bases = list(ns0.PerfProviderSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfProviderSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PerfSummaryType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PerfSummaryType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class PerfStatsType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PerfStatsType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class PerformanceManagerUnit_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PerformanceManagerUnit") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class PerfCounterInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfCounterInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfCounterInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"nameInfo"), aname="_nameInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"groupInfo"), aname="_groupInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"unitInfo"), aname="_unitInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfSummaryType",lazy=True)(pname=(ns,"rollupType"), aname="_rollupType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfStatsType",lazy=True)(pname=(ns,"statsType"), aname="_statsType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"associatedCounterId"), aname="_associatedCounterId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfCounterInfo_Def.__bases__: - bases = list(ns0.PerfCounterInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfCounterInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfCounterInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfCounterInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfCounterInfo_Def.schema - TClist = [GTD("urn:vim25","PerfCounterInfo",lazy=True)(pname=(ns,"PerfCounterInfo"), aname="_PerfCounterInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfCounterInfo = [] - return - Holder.__name__ = "ArrayOfPerfCounterInfo_Holder" - self.pyclass = Holder - - class PerfMetricId_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfMetricId") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfMetricId_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"counterId"), aname="_counterId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instance"), aname="_instance", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfMetricId_Def.__bases__: - bases = list(ns0.PerfMetricId_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfMetricId_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfMetricId_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfMetricId") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfMetricId_Def.schema - TClist = [GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"PerfMetricId"), aname="_PerfMetricId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfMetricId = [] - return - Holder.__name__ = "ArrayOfPerfMetricId_Holder" - self.pyclass = Holder - - class PerfQuerySpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfQuerySpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfQuerySpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"startTime"), aname="_startTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSample"), aname="_maxSample", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"metricId"), aname="_metricId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"intervalId"), aname="_intervalId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"format"), aname="_format", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfQuerySpec_Def.__bases__: - bases = list(ns0.PerfQuerySpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfQuerySpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfQuerySpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfQuerySpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfQuerySpec_Def.schema - TClist = [GTD("urn:vim25","PerfQuerySpec",lazy=True)(pname=(ns,"PerfQuerySpec"), aname="_PerfQuerySpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfQuerySpec = [] - return - Holder.__name__ = "ArrayOfPerfQuerySpec_Holder" - self.pyclass = Holder - - class PerfSampleInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfSampleInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfSampleInfo_Def.schema - TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfSampleInfo_Def.__bases__: - bases = list(ns0.PerfSampleInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfSampleInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfSampleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfSampleInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfSampleInfo_Def.schema - TClist = [GTD("urn:vim25","PerfSampleInfo",lazy=True)(pname=(ns,"PerfSampleInfo"), aname="_PerfSampleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfSampleInfo = [] - return - Holder.__name__ = "ArrayOfPerfSampleInfo_Holder" - self.pyclass = Holder - - class PerfMetricSeries_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfMetricSeries") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfMetricSeries_Def.schema - TClist = [GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfMetricSeries_Def.__bases__: - bases = list(ns0.PerfMetricSeries_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfMetricSeries_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfMetricSeries_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfMetricSeries") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfMetricSeries_Def.schema - TClist = [GTD("urn:vim25","PerfMetricSeries",lazy=True)(pname=(ns,"PerfMetricSeries"), aname="_PerfMetricSeries", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfMetricSeries = [] - return - Holder.__name__ = "ArrayOfPerfMetricSeries_Holder" - self.pyclass = Holder - - class PerfMetricIntSeries_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfMetricIntSeries") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfMetricIntSeries_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PerfMetricSeries_Def not in ns0.PerfMetricIntSeries_Def.__bases__: - bases = list(ns0.PerfMetricIntSeries_Def.__bases__) - bases.insert(0, ns0.PerfMetricSeries_Def) - ns0.PerfMetricIntSeries_Def.__bases__ = tuple(bases) - - ns0.PerfMetricSeries_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PerfMetricSeriesCSV_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfMetricSeriesCSV") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfMetricSeriesCSV_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PerfMetricSeries_Def not in ns0.PerfMetricSeriesCSV_Def.__bases__: - bases = list(ns0.PerfMetricSeriesCSV_Def.__bases__) - bases.insert(0, ns0.PerfMetricSeries_Def) - ns0.PerfMetricSeriesCSV_Def.__bases__ = tuple(bases) - - ns0.PerfMetricSeries_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfMetricSeriesCSV_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfMetricSeriesCSV") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfMetricSeriesCSV_Def.schema - TClist = [GTD("urn:vim25","PerfMetricSeriesCSV",lazy=True)(pname=(ns,"PerfMetricSeriesCSV"), aname="_PerfMetricSeriesCSV", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfMetricSeriesCSV = [] - return - Holder.__name__ = "ArrayOfPerfMetricSeriesCSV_Holder" - self.pyclass = Holder - - class PerfEntityMetricBase_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfEntityMetricBase") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfEntityMetricBase_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfEntityMetricBase_Def.__bases__: - bases = list(ns0.PerfEntityMetricBase_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfEntityMetricBase_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfEntityMetricBase_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfEntityMetricBase") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfEntityMetricBase_Def.schema - TClist = [GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"PerfEntityMetricBase"), aname="_PerfEntityMetricBase", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfEntityMetricBase = [] - return - Holder.__name__ = "ArrayOfPerfEntityMetricBase_Holder" - self.pyclass = Holder - - class PerfEntityMetric_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfEntityMetric") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfEntityMetric_Def.schema - TClist = [GTD("urn:vim25","PerfSampleInfo",lazy=True)(pname=(ns,"sampleInfo"), aname="_sampleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricSeries",lazy=True)(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PerfEntityMetricBase_Def not in ns0.PerfEntityMetric_Def.__bases__: - bases = list(ns0.PerfEntityMetric_Def.__bases__) - bases.insert(0, ns0.PerfEntityMetricBase_Def) - ns0.PerfEntityMetric_Def.__bases__ = tuple(bases) - - ns0.PerfEntityMetricBase_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PerfEntityMetricCSV_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfEntityMetricCSV") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfEntityMetricCSV_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"sampleInfoCSV"), aname="_sampleInfoCSV", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricSeriesCSV",lazy=True)(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PerfEntityMetricBase_Def not in ns0.PerfEntityMetricCSV_Def.__bases__: - bases = list(ns0.PerfEntityMetricCSV_Def.__bases__) - bases.insert(0, ns0.PerfEntityMetricBase_Def) - ns0.PerfEntityMetricCSV_Def.__bases__ = tuple(bases) - - ns0.PerfEntityMetricBase_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PerfCompositeMetric_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfCompositeMetric") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfCompositeMetric_Def.schema - TClist = [GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"childEntity"), aname="_childEntity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfCompositeMetric_Def.__bases__: - bases = list(ns0.PerfCompositeMetric_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfCompositeMetric_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class QueryPerfProviderSummaryRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPerfProviderSummaryRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPerfProviderSummaryRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - return - Holder.__name__ = "QueryPerfProviderSummaryRequestType_Holder" - self.pyclass = Holder - - class QueryAvailablePerfMetricRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryAvailablePerfMetricRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryAvailablePerfMetricRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"beginTime"), aname="_beginTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"intervalId"), aname="_intervalId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._beginTime = None - self._endTime = None - self._intervalId = None - return - Holder.__name__ = "QueryAvailablePerfMetricRequestType_Holder" - self.pyclass = Holder - - class QueryPerfCounterRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPerfCounterRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPerfCounterRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"counterId"), aname="_counterId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._counterId = [] - return - Holder.__name__ = "QueryPerfCounterRequestType_Holder" - self.pyclass = Holder - - class QueryPerfCounterByLevelRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPerfCounterByLevelRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPerfCounterByLevelRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._level = None - return - Holder.__name__ = "QueryPerfCounterByLevelRequestType_Holder" - self.pyclass = Holder - - class QueryPerfRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPerfRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPerfRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfQuerySpec",lazy=True)(pname=(ns,"querySpec"), aname="_querySpec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._querySpec = [] - return - Holder.__name__ = "QueryPerfRequestType_Holder" - self.pyclass = Holder - - class QueryPerfCompositeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPerfCompositeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPerfCompositeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfQuerySpec",lazy=True)(pname=(ns,"querySpec"), aname="_querySpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._querySpec = None - return - Holder.__name__ = "QueryPerfCompositeRequestType_Holder" - self.pyclass = Holder - - class CreatePerfIntervalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreatePerfIntervalRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreatePerfIntervalRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"intervalId"), aname="_intervalId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._intervalId = None - return - Holder.__name__ = "CreatePerfIntervalRequestType_Holder" - self.pyclass = Holder - - class RemovePerfIntervalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemovePerfIntervalRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemovePerfIntervalRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"samplePeriod"), aname="_samplePeriod", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._samplePeriod = None - return - Holder.__name__ = "RemovePerfIntervalRequestType_Holder" - self.pyclass = Holder - - class UpdatePerfIntervalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdatePerfIntervalRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdatePerfIntervalRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._interval = None - return - Holder.__name__ = "UpdatePerfIntervalRequestType_Holder" - self.pyclass = Holder - - class PerfInterval_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerfInterval") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerfInterval_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"samplingPeriod"), aname="_samplingPeriod", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"length"), aname="_length", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerfInterval_Def.__bases__: - bases = list(ns0.PerfInterval_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerfInterval_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPerfInterval_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPerfInterval") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPerfInterval_Def.schema - TClist = [GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"PerfInterval"), aname="_PerfInterval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PerfInterval = [] - return - Holder.__name__ = "ArrayOfPerfInterval_Holder" - self.pyclass = Holder - - class PosixUserSearchResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PosixUserSearchResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PosixUserSearchResult_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shellAccess"), aname="_shellAccess", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.UserSearchResult_Def not in ns0.PosixUserSearchResult_Def.__bases__: - bases = list(ns0.PosixUserSearchResult_Def.__bases__) - bases.insert(0, ns0.UserSearchResult_Def) - ns0.PosixUserSearchResult_Def.__bases__ = tuple(bases) - - ns0.UserSearchResult_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PrivilegePolicyDef_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PrivilegePolicyDef") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PrivilegePolicyDef_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"createPrivilege"), aname="_createPrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"readPrivilege"), aname="_readPrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"updatePrivilege"), aname="_updatePrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deletePrivilege"), aname="_deletePrivilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PrivilegePolicyDef_Def.__bases__: - bases = list(ns0.PrivilegePolicyDef_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PrivilegePolicyDef_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourceAllocationInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourceAllocationInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourceAllocationInfo_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"reservation"), aname="_reservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"expandableReservation"), aname="_expandableReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"limit"), aname="_limit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SharesInfo",lazy=True)(pname=(ns,"shares"), aname="_shares", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overheadLimit"), aname="_overheadLimit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ResourceAllocationInfo_Def.__bases__: - bases = list(ns0.ResourceAllocationInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ResourceAllocationInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourceConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourceConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourceConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModified"), aname="_lastModified", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"cpuAllocation"), aname="_cpuAllocation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"memoryAllocation"), aname="_memoryAllocation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ResourceConfigSpec_Def.__bases__: - bases = list(ns0.ResourceConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ResourceConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfResourceConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfResourceConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfResourceConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"ResourceConfigSpec"), aname="_ResourceConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ResourceConfigSpec = [] - return - Holder.__name__ = "ArrayOfResourceConfigSpec_Holder" - self.pyclass = Holder - - class DatabaseSizeParam_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatabaseSizeParam") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatabaseSizeParam_Def.schema - TClist = [GTD("urn:vim25","InventoryDescription",lazy=True)(pname=(ns,"inventoryDesc"), aname="_inventoryDesc", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerformanceStatisticsDescription",lazy=True)(pname=(ns,"perfStatsDesc"), aname="_perfStatsDesc", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatabaseSizeParam_Def.__bases__: - bases = list(ns0.DatabaseSizeParam_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatabaseSizeParam_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InventoryDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InventoryDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InventoryDescription_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numHosts"), aname="_numHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVirtualMachines"), aname="_numVirtualMachines", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numResourcePools"), aname="_numResourcePools", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numClusters"), aname="_numClusters", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuDev"), aname="_numCpuDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNetDev"), aname="_numNetDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numDiskDev"), aname="_numDiskDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numvCpuDev"), aname="_numvCpuDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numvNetDev"), aname="_numvNetDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numvDiskDev"), aname="_numvDiskDev", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.InventoryDescription_Def.__bases__: - bases = list(ns0.InventoryDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.InventoryDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PerformanceStatisticsDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PerformanceStatisticsDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PerformanceStatisticsDescription_Def.schema - TClist = [GTD("urn:vim25","PerfInterval",lazy=True)(pname=(ns,"intervals"), aname="_intervals", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PerformanceStatisticsDescription_Def.__bases__: - bases = list(ns0.PerformanceStatisticsDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PerformanceStatisticsDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatabaseSizeEstimate_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatabaseSizeEstimate") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatabaseSizeEstimate_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatabaseSizeEstimate_Def.__bases__: - bases = list(ns0.DatabaseSizeEstimate_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatabaseSizeEstimate_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GetDatabaseSizeEstimateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "GetDatabaseSizeEstimateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.GetDatabaseSizeEstimateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatabaseSizeParam",lazy=True)(pname=(ns,"dbSizeParam"), aname="_dbSizeParam", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dbSizeParam = None - return - Holder.__name__ = "GetDatabaseSizeEstimateRequestType_Holder" - self.pyclass = Holder - - class ResourcePoolResourceUsage_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolResourceUsage") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolResourceUsage_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"reservationUsed"), aname="_reservationUsed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"reservationUsedForVm"), aname="_reservationUsedForVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unreservedForPool"), aname="_unreservedForPool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unreservedForVm"), aname="_unreservedForVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overallUsage"), aname="_overallUsage", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxUsage"), aname="_maxUsage", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ResourcePoolResourceUsage_Def.__bases__: - bases = list(ns0.ResourcePoolResourceUsage_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ResourcePoolResourceUsage_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolRuntimeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolRuntimeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolRuntimeInfo_Def.schema - TClist = [GTD("urn:vim25","ResourcePoolResourceUsage",lazy=True)(pname=(ns,"memory"), aname="_memory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolResourceUsage",lazy=True)(pname=(ns,"cpu"), aname="_cpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ResourcePoolRuntimeInfo_Def.__bases__: - bases = list(ns0.ResourcePoolRuntimeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ResourcePoolRuntimeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolQuickStats_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolQuickStats") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolQuickStats_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"overallCpuUsage"), aname="_overallCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overallCpuDemand"), aname="_overallCpuDemand", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"guestMemoryUsage"), aname="_guestMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hostMemoryUsage"), aname="_hostMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"distributedCpuEntitlement"), aname="_distributedCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"distributedMemoryEntitlement"), aname="_distributedMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticCpuEntitlement"), aname="_staticCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticMemoryEntitlement"), aname="_staticMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"privateMemory"), aname="_privateMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"sharedMemory"), aname="_sharedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"swappedMemory"), aname="_swappedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"balloonedMemory"), aname="_balloonedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"overheadMemory"), aname="_overheadMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"consumedOverheadMemory"), aname="_consumedOverheadMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ResourcePoolQuickStats_Def.__bases__: - bases = list(ns0.ResourcePoolQuickStats_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ResourcePoolQuickStats_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolSummary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolRuntimeInfo",lazy=True)(pname=(ns,"runtime"), aname="_runtime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolQuickStats",lazy=True)(pname=(ns,"quickStats"), aname="_quickStats", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"configuredMemoryMB"), aname="_configuredMemoryMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ResourcePoolSummary_Def.__bases__: - bases = list(ns0.ResourcePoolSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ResourcePoolSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._config = None - return - Holder.__name__ = "UpdateConfigRequestType_Holder" - self.pyclass = Holder - - class MoveIntoResourcePoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MoveIntoResourcePoolRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MoveIntoResourcePoolRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"list"), aname="_list", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._list = [] - return - Holder.__name__ = "MoveIntoResourcePoolRequestType_Holder" - self.pyclass = Holder - - class UpdateChildResourceConfigurationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateChildResourceConfigurationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateChildResourceConfigurationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = [] - return - Holder.__name__ = "UpdateChildResourceConfigurationRequestType_Holder" - self.pyclass = Holder - - class CreateResourcePoolRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateResourcePoolRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateResourcePoolRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._spec = None - return - Holder.__name__ = "CreateResourcePoolRequestType_Holder" - self.pyclass = Holder - - class DestroyChildrenRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyChildrenRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyChildrenRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DestroyChildrenRequestType_Holder" - self.pyclass = Holder - - class CreateVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateVAppRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateVAppRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"resSpec"), aname="_resSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmFolder"), aname="_vmFolder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._resSpec = None - self._configSpec = None - self._vmFolder = None - return - Holder.__name__ = "CreateVAppRequestType_Holder" - self.pyclass = Holder - - class CreateChildVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateChildVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateChildVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - self._host = None - return - Holder.__name__ = "CreateChildVMRequestType_Holder" - self.pyclass = Holder - - class RegisterChildVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RegisterChildVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RegisterChildVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._path = None - self._name = None - self._host = None - return - Holder.__name__ = "RegisterChildVMRequestType_Holder" - self.pyclass = Holder - - class ImportVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ImportVAppRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ImportVAppRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"folder"), aname="_folder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - self._folder = None - self._host = None - return - Holder.__name__ = "ImportVAppRequestType_Holder" - self.pyclass = Holder - - class FindByUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindByUuidRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindByUuidRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datacenter = None - self._uuid = None - self._vmSearch = None - self._instanceUuid = None - return - Holder.__name__ = "FindByUuidRequestType_Holder" - self.pyclass = Holder - - class FindByDatastorePathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindByDatastorePathRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindByDatastorePathRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datacenter = None - self._path = None - return - Holder.__name__ = "FindByDatastorePathRequestType_Holder" - self.pyclass = Holder - - class FindByDnsNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindByDnsNameRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindByDnsNameRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsName"), aname="_dnsName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datacenter = None - self._dnsName = None - self._vmSearch = None - return - Holder.__name__ = "FindByDnsNameRequestType_Holder" - self.pyclass = Holder - - class FindByIpRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindByIpRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindByIpRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datacenter = None - self._ip = None - self._vmSearch = None - return - Holder.__name__ = "FindByIpRequestType_Holder" - self.pyclass = Holder - - class FindByInventoryPathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindByInventoryPathRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindByInventoryPathRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"inventoryPath"), aname="_inventoryPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._inventoryPath = None - return - Holder.__name__ = "FindByInventoryPathRequestType_Holder" - self.pyclass = Holder - - class FindChildRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindChildRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindChildRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._name = None - return - Holder.__name__ = "FindChildRequestType_Holder" - self.pyclass = Holder - - class FindAllByUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindAllByUuidRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindAllByUuidRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datacenter = None - self._uuid = None - self._vmSearch = None - self._instanceUuid = None - return - Holder.__name__ = "FindAllByUuidRequestType_Holder" - self.pyclass = Holder - - class FindAllByDnsNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindAllByDnsNameRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindAllByDnsNameRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsName"), aname="_dnsName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datacenter = None - self._dnsName = None - self._vmSearch = None - return - Holder.__name__ = "FindAllByDnsNameRequestType_Holder" - self.pyclass = Holder - - class FindAllByIpRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FindAllByIpRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FindAllByIpRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmSearch"), aname="_vmSearch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datacenter = None - self._ip = None - self._vmSearch = None - return - Holder.__name__ = "FindAllByIpRequestType_Holder" - self.pyclass = Holder - - class ValidateMigrationTestType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ValidateMigrationTestType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VMotionCompatibilityType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VMotionCompatibilityType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostVMotionCompatibility_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVMotionCompatibility") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVMotionCompatibility_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compatibility"), aname="_compatibility", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVMotionCompatibility_Def.__bases__: - bases = list(ns0.HostVMotionCompatibility_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVMotionCompatibility_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostVMotionCompatibility_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostVMotionCompatibility") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostVMotionCompatibility_Def.schema - TClist = [GTD("urn:vim25","HostVMotionCompatibility",lazy=True)(pname=(ns,"HostVMotionCompatibility"), aname="_HostVMotionCompatibility", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostVMotionCompatibility = [] - return - Holder.__name__ = "ArrayOfHostVMotionCompatibility_Holder" - self.pyclass = Holder - - class ProductComponentInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProductComponentInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProductComponentInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"release"), aname="_release", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProductComponentInfo_Def.__bases__: - bases = list(ns0.ProductComponentInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProductComponentInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProductComponentInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProductComponentInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProductComponentInfo_Def.schema - TClist = [GTD("urn:vim25","ProductComponentInfo",lazy=True)(pname=(ns,"ProductComponentInfo"), aname="_ProductComponentInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProductComponentInfo = [] - return - Holder.__name__ = "ArrayOfProductComponentInfo_Holder" - self.pyclass = Holder - - class CurrentTimeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CurrentTimeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CurrentTimeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "CurrentTimeRequestType_Holder" - self.pyclass = Holder - - class RetrieveServiceContentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveServiceContentRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveServiceContentRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RetrieveServiceContentRequestType_Holder" - self.pyclass = Holder - - class ValidateMigrationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ValidateMigrationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ValidateMigrationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = [] - self._state = None - self._testType = [] - self._pool = None - self._host = None - return - Holder.__name__ = "ValidateMigrationRequestType_Holder" - self.pyclass = Holder - - class QueryVMotionCompatibilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVMotionCompatibilityRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVMotionCompatibilityRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compatibility"), aname="_compatibility", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - self._host = [] - self._compatibility = [] - return - Holder.__name__ = "QueryVMotionCompatibilityRequestType_Holder" - self.pyclass = Holder - - class RetrieveProductComponentsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveProductComponentsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveProductComponentsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RetrieveProductComponentsRequestType_Holder" - self.pyclass = Holder - - class ServiceContent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ServiceContent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ServiceContent_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"rootFolder"), aname="_rootFolder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"propertyCollector"), aname="_propertyCollector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"viewManager"), aname="_viewManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AboutInfo",lazy=True)(pname=(ns,"about"), aname="_about", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"userDirectory"), aname="_userDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sessionManager"), aname="_sessionManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"authorizationManager"), aname="_authorizationManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"perfManager"), aname="_perfManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTaskManager"), aname="_scheduledTaskManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarmManager"), aname="_alarmManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"eventManager"), aname="_eventManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"taskManager"), aname="_taskManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"extensionManager"), aname="_extensionManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"customizationSpecManager"), aname="_customizationSpecManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"customFieldsManager"), aname="_customFieldsManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"accountManager"), aname="_accountManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"diagnosticManager"), aname="_diagnosticManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"licenseManager"), aname="_licenseManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"searchIndex"), aname="_searchIndex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"fileManager"), aname="_fileManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"virtualDiskManager"), aname="_virtualDiskManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"virtualizationManager"), aname="_virtualizationManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snmpSystem"), aname="_snmpSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmProvisioningChecker"), aname="_vmProvisioningChecker", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmCompatibilityChecker"), aname="_vmCompatibilityChecker", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"ovfManager"), aname="_ovfManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"ipPoolManager"), aname="_ipPoolManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvSwitchManager"), aname="_dvSwitchManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"hostProfileManager"), aname="_hostProfileManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"clusterProfileManager"), aname="_clusterProfileManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"complianceManager"), aname="_complianceManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"localizationManager"), aname="_localizationManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ServiceContent_Def.__bases__: - bases = list(ns0.ServiceContent_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ServiceContent_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SessionManagerLocalTicket_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SessionManagerLocalTicket") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SessionManagerLocalTicket_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"passwordFilePath"), aname="_passwordFilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.SessionManagerLocalTicket_Def.__bases__: - bases = list(ns0.SessionManagerLocalTicket_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.SessionManagerLocalTicket_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateServiceMessageRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateServiceMessageRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateServiceMessageRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._message = None - return - Holder.__name__ = "UpdateServiceMessageRequestType_Holder" - self.pyclass = Holder - - class LoginRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LoginRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.LoginRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._userName = None - self._password = None - self._locale = None - return - Holder.__name__ = "LoginRequestType_Holder" - self.pyclass = Holder - - class LoginBySSPIRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LoginBySSPIRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.LoginBySSPIRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"base64Token"), aname="_base64Token", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._base64Token = None - self._locale = None - return - Holder.__name__ = "LoginBySSPIRequestType_Holder" - self.pyclass = Holder - - class LogoutRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LogoutRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.LogoutRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "LogoutRequestType_Holder" - self.pyclass = Holder - - class AcquireLocalTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AcquireLocalTicketRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AcquireLocalTicketRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._userName = None - return - Holder.__name__ = "AcquireLocalTicketRequestType_Holder" - self.pyclass = Holder - - class TerminateSessionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "TerminateSessionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.TerminateSessionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._sessionId = [] - return - Holder.__name__ = "TerminateSessionRequestType_Holder" - self.pyclass = Holder - - class SetLocaleRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetLocaleRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetLocaleRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._locale = None - return - Holder.__name__ = "SetLocaleRequestType_Holder" - self.pyclass = Holder - - class LoginExtensionBySubjectNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LoginExtensionBySubjectNameRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.LoginExtensionBySubjectNameRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"extensionKey"), aname="_extensionKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._extensionKey = None - self._locale = None - return - Holder.__name__ = "LoginExtensionBySubjectNameRequestType_Holder" - self.pyclass = Holder - - class ImpersonateUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ImpersonateUserRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ImpersonateUserRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._userName = None - self._locale = None - return - Holder.__name__ = "ImpersonateUserRequestType_Holder" - self.pyclass = Holder - - class SessionIsActiveRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SessionIsActiveRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SessionIsActiveRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionID"), aname="_sessionID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._sessionID = None - self._userName = None - return - Holder.__name__ = "SessionIsActiveRequestType_Holder" - self.pyclass = Holder - - class AcquireCloneTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AcquireCloneTicketRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AcquireCloneTicketRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "AcquireCloneTicketRequestType_Holder" - self.pyclass = Holder - - class CloneSessionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CloneSessionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CloneSessionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cloneTicket"), aname="_cloneTicket", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._cloneTicket = None - return - Holder.__name__ = "CloneSessionRequestType_Holder" - self.pyclass = Holder - - class UserSession_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserSession") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserSession_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"loginTime"), aname="_loginTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastActiveTime"), aname="_lastActiveTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"messageLocale"), aname="_messageLocale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.UserSession_Def.__bases__: - bases = list(ns0.UserSession_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.UserSession_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfUserSession_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfUserSession") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfUserSession_Def.schema - TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"UserSession"), aname="_UserSession", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._UserSession = [] - return - Holder.__name__ = "ArrayOfUserSession_Holder" - self.pyclass = Holder - - class SharesLevel_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SharesLevel") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class SharesInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SharesInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SharesInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"shares"), aname="_shares", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SharesLevel",lazy=True)(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.SharesInfo_Def.__bases__: - bases = list(ns0.SharesInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.SharesInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class StringPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "StringPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.StringPolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.StringPolicy_Def.__bases__: - bases = list(ns0.StringPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.StringPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class Tag_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Tag") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Tag_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.Tag_Def.__bases__: - bases = list(ns0.Tag_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.Tag_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfTag_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfTag") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfTag_Def.schema - TClist = [GTD("urn:vim25","Tag",lazy=True)(pname=(ns,"Tag"), aname="_Tag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._Tag = [] - return - Holder.__name__ = "ArrayOfTag_Holder" - self.pyclass = Holder - - class CancelTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CancelTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CancelTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "CancelTaskRequestType_Holder" - self.pyclass = Holder - - class UpdateProgressRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateProgressRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateProgressRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"percentDone"), aname="_percentDone", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._percentDone = None - return - Holder.__name__ = "UpdateProgressRequestType_Holder" - self.pyclass = Holder - - class SetTaskStateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetTaskStateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetTaskStateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"result"), aname="_result", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._state = None - self._result = None - self._fault = None - return - Holder.__name__ = "SetTaskStateRequestType_Holder" - self.pyclass = Holder - - class SetTaskDescriptionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetTaskDescriptionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetTaskDescriptionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._description = None - return - Holder.__name__ = "SetTaskDescriptionRequestType_Holder" - self.pyclass = Holder - - class TaskDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskDescription_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"methodInfo"), aname="_methodInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskDescription_Def.__bases__: - bases = list(ns0.TaskDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskFilterSpecRecursionOption_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "TaskFilterSpecRecursionOption") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class TaskFilterSpecTimeOption_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "TaskFilterSpecTimeOption") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class TaskFilterSpecByEntity_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskFilterSpecByEntity") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskFilterSpecByEntity_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpecRecursionOption",lazy=True)(pname=(ns,"recursion"), aname="_recursion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskFilterSpecByEntity_Def.__bases__: - bases = list(ns0.TaskFilterSpecByEntity_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskFilterSpecByEntity_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskFilterSpecByTime_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskFilterSpecByTime") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskFilterSpecByTime_Def.schema - TClist = [GTD("urn:vim25","TaskFilterSpecTimeOption",lazy=True)(pname=(ns,"timeType"), aname="_timeType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"beginTime"), aname="_beginTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskFilterSpecByTime_Def.__bases__: - bases = list(ns0.TaskFilterSpecByTime_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskFilterSpecByTime_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskFilterSpecByUsername_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskFilterSpecByUsername") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskFilterSpecByUsername_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"systemUser"), aname="_systemUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userList"), aname="_userList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskFilterSpecByUsername_Def.__bases__: - bases = list(ns0.TaskFilterSpecByUsername_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskFilterSpecByUsername_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskFilterSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskFilterSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskFilterSpec_Def.schema - TClist = [GTD("urn:vim25","TaskFilterSpecByEntity",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpecByTime",lazy=True)(pname=(ns,"time"), aname="_time", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpecByUsername",lazy=True)(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"eventChainId"), aname="_eventChainId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"tag"), aname="_tag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentTaskKey"), aname="_parentTaskKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rootTaskKey"), aname="_rootTaskKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskFilterSpec_Def.__bases__: - bases = list(ns0.TaskFilterSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskFilterSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReadNextTasksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReadNextTasksRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReadNextTasksRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._maxCount = None - return - Holder.__name__ = "ReadNextTasksRequestType_Holder" - self.pyclass = Holder - - class ReadPreviousTasksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReadPreviousTasksRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReadPreviousTasksRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._maxCount = None - return - Holder.__name__ = "ReadPreviousTasksRequestType_Holder" - self.pyclass = Holder - - class TaskInfoState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "TaskInfoState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ArrayOfTaskInfoState_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfTaskInfoState") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfTaskInfoState_Def.schema - TClist = [GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"TaskInfoState"), aname="_TaskInfoState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._TaskInfoState = [] - return - Holder.__name__ = "ArrayOfTaskInfoState_Holder" - self.pyclass = Holder - - class TaskInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"task"), aname="_task", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"descriptionId"), aname="_descriptionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"locked"), aname="_locked", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelled"), aname="_cancelled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelable"), aname="_cancelable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"result"), aname="_result", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"progress"), aname="_progress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskReason",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"queueTime"), aname="_queueTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"startTime"), aname="_startTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"completeTime"), aname="_completeTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"eventChainId"), aname="_eventChainId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeTag"), aname="_changeTag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentTaskKey"), aname="_parentTaskKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rootTaskKey"), aname="_rootTaskKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskInfo_Def.__bases__: - bases = list(ns0.TaskInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfTaskInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfTaskInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfTaskInfo_Def.schema - TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"TaskInfo"), aname="_TaskInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._TaskInfo = [] - return - Holder.__name__ = "ArrayOfTaskInfo_Holder" - self.pyclass = Holder - - class CreateCollectorForTasksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateCollectorForTasksRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateCollectorForTasksRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskFilterSpec",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._filter = None - return - Holder.__name__ = "CreateCollectorForTasksRequestType_Holder" - self.pyclass = Holder - - class CreateTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"taskTypeId"), aname="_taskTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"initiatedBy"), aname="_initiatedBy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelable"), aname="_cancelable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentTaskKey"), aname="_parentTaskKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._obj = None - self._taskTypeId = None - self._initiatedBy = None - self._cancelable = None - self._parentTaskKey = None - return - Holder.__name__ = "CreateTaskRequestType_Holder" - self.pyclass = Holder - - class TaskReason_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskReason") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskReason_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskReason_Def.__bases__: - bases = list(ns0.TaskReason_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskReason_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskReasonSystem_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskReasonSystem") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskReasonSystem_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskReason_Def not in ns0.TaskReasonSystem_Def.__bases__: - bases = list(ns0.TaskReasonSystem_Def.__bases__) - bases.insert(0, ns0.TaskReason_Def) - ns0.TaskReasonSystem_Def.__bases__ = tuple(bases) - - ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskReasonUser_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskReasonUser") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskReasonUser_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskReason_Def not in ns0.TaskReasonUser_Def.__bases__: - bases = list(ns0.TaskReasonUser_Def.__bases__) - bases.insert(0, ns0.TaskReason_Def) - ns0.TaskReasonUser_Def.__bases__ = tuple(bases) - - ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskReasonAlarm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskReasonAlarm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskReasonAlarm_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"alarmName"), aname="_alarmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskReason_Def not in ns0.TaskReasonAlarm_Def.__bases__: - bases = list(ns0.TaskReasonAlarm_Def.__bases__) - bases.insert(0, ns0.TaskReason_Def) - ns0.TaskReasonAlarm_Def.__bases__ = tuple(bases) - - ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskReasonSchedule_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskReasonSchedule") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskReasonSchedule_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskReason_Def not in ns0.TaskReasonSchedule_Def.__bases__: - bases = list(ns0.TaskReasonSchedule_Def.__bases__) - bases.insert(0, ns0.TaskReason_Def) - ns0.TaskReasonSchedule_Def.__bases__ = tuple(bases) - - ns0.TaskReason_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TypeDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TypeDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TypeDescription_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Description_Def not in ns0.TypeDescription_Def.__bases__: - bases = list(ns0.TypeDescription_Def.__bases__) - bases.insert(0, ns0.Description_Def) - ns0.TypeDescription_Def.__bases__ = tuple(bases) - - ns0.Description_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfTypeDescription_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfTypeDescription") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfTypeDescription_Def.schema - TClist = [GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"TypeDescription"), aname="_TypeDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._TypeDescription = [] - return - Holder.__name__ = "ArrayOfTypeDescription_Holder" - self.pyclass = Holder - - class RetrieveUserGroupsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveUserGroupsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveUserGroupsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domain"), aname="_domain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"searchStr"), aname="_searchStr", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"belongsToGroup"), aname="_belongsToGroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"belongsToUser"), aname="_belongsToUser", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"exactMatch"), aname="_exactMatch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"findUsers"), aname="_findUsers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"findGroups"), aname="_findGroups", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._domain = None - self._searchStr = None - self._belongsToGroup = None - self._belongsToUser = None - self._exactMatch = None - self._findUsers = None - self._findGroups = None - return - Holder.__name__ = "RetrieveUserGroupsRequestType_Holder" - self.pyclass = Holder - - class UserSearchResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserSearchResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserSearchResult_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.UserSearchResult_Def.__bases__: - bases = list(ns0.UserSearchResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.UserSearchResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfUserSearchResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfUserSearchResult") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfUserSearchResult_Def.schema - TClist = [GTD("urn:vim25","UserSearchResult",lazy=True)(pname=(ns,"UserSearchResult"), aname="_UserSearchResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._UserSearchResult = [] - return - Holder.__name__ = "ArrayOfUserSearchResult_Holder" - self.pyclass = Holder - - class VirtualAppVAppState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualAppVAppState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualAppSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualAppSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualAppSummary_Def.schema - TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualAppVAppState",lazy=True)(pname=(ns,"vAppState"), aname="_vAppState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ResourcePoolSummary_Def not in ns0.VirtualAppSummary_Def.__bases__: - bases = list(ns0.VirtualAppSummary_Def.__bases__) - bases.insert(0, ns0.ResourcePoolSummary_Def) - ns0.VirtualAppSummary_Def.__bases__ = tuple(bases) - - ns0.ResourcePoolSummary_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateVAppConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateVAppConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateVAppConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "UpdateVAppConfigRequestType_Holder" - self.pyclass = Holder - - class CloneVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CloneVAppRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CloneVAppRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppCloneSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._target = None - self._spec = None - return - Holder.__name__ = "CloneVAppRequestType_Holder" - self.pyclass = Holder - - class ExportVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExportVAppRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExportVAppRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ExportVAppRequestType_Holder" - self.pyclass = Holder - - class PowerOnVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PowerOnVAppRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PowerOnVAppRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "PowerOnVAppRequestType_Holder" - self.pyclass = Holder - - class PowerOffVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PowerOffVAppRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PowerOffVAppRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._force = None - return - Holder.__name__ = "PowerOffVAppRequestType_Holder" - self.pyclass = Holder - - class unregisterVAppRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "unregisterVAppRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.unregisterVAppRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "unregisterVAppRequestType_Holder" - self.pyclass = Holder - - class VirtualDiskType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDiskType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDiskAdapterType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDiskAdapterType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDiskSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskType"), aname="_diskType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapterType"), aname="_adapterType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDiskSpec_Def.__bases__: - bases = list(ns0.VirtualDiskSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDiskSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileBackedVirtualDiskSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileBackedVirtualDiskSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileBackedVirtualDiskSpec_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"capacityKb"), aname="_capacityKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDiskSpec_Def not in ns0.FileBackedVirtualDiskSpec_Def.__bases__: - bases = list(ns0.FileBackedVirtualDiskSpec_Def.__bases__) - bases.insert(0, ns0.VirtualDiskSpec_Def) - ns0.FileBackedVirtualDiskSpec_Def.__bases__ = tuple(bases) - - ns0.VirtualDiskSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceBackedVirtualDiskSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceBackedVirtualDiskSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceBackedVirtualDiskSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDiskSpec_Def not in ns0.DeviceBackedVirtualDiskSpec_Def.__bases__: - bases = list(ns0.DeviceBackedVirtualDiskSpec_Def.__bases__) - bases.insert(0, ns0.VirtualDiskSpec_Def) - ns0.DeviceBackedVirtualDiskSpec_Def.__bases__ = tuple(bases) - - ns0.VirtualDiskSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CreateVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - self._spec = None - return - Holder.__name__ = "CreateVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class DeleteVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DeleteVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DeleteVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "DeleteVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class MoveVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MoveVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MoveVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destDatacenter"), aname="_destDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._sourceName = None - self._sourceDatacenter = None - self._destName = None - self._destDatacenter = None - self._force = None - return - Holder.__name__ = "MoveVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class CopyVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CopyVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CopyVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceName"), aname="_sourceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"sourceDatacenter"), aname="_sourceDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destDatacenter"), aname="_destDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSpec",lazy=True)(pname=(ns,"destSpec"), aname="_destSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._sourceName = None - self._sourceDatacenter = None - self._destName = None - self._destDatacenter = None - self._destSpec = None - self._force = None - return - Holder.__name__ = "CopyVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class ExtendVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExtendVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExtendVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newCapacityKb"), aname="_newCapacityKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"eagerZero"), aname="_eagerZero", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - self._newCapacityKb = None - self._eagerZero = None - return - Holder.__name__ = "ExtendVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class QueryVirtualDiskFragmentationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVirtualDiskFragmentationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVirtualDiskFragmentationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "QueryVirtualDiskFragmentationRequestType_Holder" - self.pyclass = Holder - - class DefragmentVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DefragmentVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DefragmentVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "DefragmentVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class ShrinkVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ShrinkVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ShrinkVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"copy"), aname="_copy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - self._copy = None - return - Holder.__name__ = "ShrinkVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class InflateVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "InflateVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.InflateVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "InflateVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class EagerZeroVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EagerZeroVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.EagerZeroVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "EagerZeroVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class ZeroFillVirtualDiskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ZeroFillVirtualDiskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ZeroFillVirtualDiskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "ZeroFillVirtualDiskRequestType_Holder" - self.pyclass = Holder - - class SetVirtualDiskUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetVirtualDiskUuidRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetVirtualDiskUuidRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - self._uuid = None - return - Holder.__name__ = "SetVirtualDiskUuidRequestType_Holder" - self.pyclass = Holder - - class QueryVirtualDiskUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVirtualDiskUuidRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVirtualDiskUuidRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "QueryVirtualDiskUuidRequestType_Holder" - self.pyclass = Holder - - class QueryVirtualDiskGeometryRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVirtualDiskGeometryRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVirtualDiskGeometryRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._datacenter = None - return - Holder.__name__ = "QueryVirtualDiskGeometryRequestType_Holder" - self.pyclass = Holder - - class VirtualMachinePowerState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachinePowerState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineConnectionState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineConnectionState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineMovePriority_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineMovePriority") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineMksTicket_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineMksTicket") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineMksTicket_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ticket"), aname="_ticket", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cfgFile"), aname="_cfgFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineMksTicket_Def.__bases__: - bases = list(ns0.VirtualMachineMksTicket_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineMksTicket_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineFaultToleranceState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineFaultToleranceState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineRecordReplayState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineRecordReplayState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineNeedSecondaryReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineNeedSecondaryReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineDisplayTopology_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineDisplayTopology") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineDisplayTopology_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"x"), aname="_x", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"y"), aname="_y", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineDisplayTopology_Def.__bases__: - bases = list(ns0.VirtualMachineDisplayTopology_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineDisplayTopology_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineDisplayTopology_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineDisplayTopology") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineDisplayTopology_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineDisplayTopology",lazy=True)(pname=(ns,"VirtualMachineDisplayTopology"), aname="_VirtualMachineDisplayTopology", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineDisplayTopology = [] - return - Holder.__name__ = "ArrayOfVirtualMachineDisplayTopology_Holder" - self.pyclass = Holder - - class DiskChangeExtent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DiskChangeExtent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DiskChangeExtent_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"start"), aname="_start", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"length"), aname="_length", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DiskChangeExtent_Def.__bases__: - bases = list(ns0.DiskChangeExtent_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DiskChangeExtent_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDiskChangeExtent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDiskChangeExtent") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDiskChangeExtent_Def.schema - TClist = [GTD("urn:vim25","DiskChangeExtent",lazy=True)(pname=(ns,"DiskChangeExtent"), aname="_DiskChangeExtent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DiskChangeExtent = [] - return - Holder.__name__ = "ArrayOfDiskChangeExtent_Holder" - self.pyclass = Holder - - class DiskChangeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DiskChangeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DiskChangeInfo_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"startOffset"), aname="_startOffset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"length"), aname="_length", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DiskChangeExtent",lazy=True)(pname=(ns,"changedArea"), aname="_changedArea", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DiskChangeInfo_Def.__bases__: - bases = list(ns0.DiskChangeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DiskChangeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RefreshStorageInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshStorageInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshStorageInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshStorageInfoRequestType_Holder" - self.pyclass = Holder - - class CreateSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateSnapshotRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateSnapshotRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memory"), aname="_memory", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"quiesce"), aname="_quiesce", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._description = None - self._memory = None - self._quiesce = None - return - Holder.__name__ = "CreateSnapshotRequestType_Holder" - self.pyclass = Holder - - class RevertToCurrentSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RevertToCurrentSnapshotRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RevertToCurrentSnapshotRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suppressPowerOn"), aname="_suppressPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._suppressPowerOn = None - return - Holder.__name__ = "RevertToCurrentSnapshotRequestType_Holder" - self.pyclass = Holder - - class RemoveAllSnapshotsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveAllSnapshotsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveAllSnapshotsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RemoveAllSnapshotsRequestType_Holder" - self.pyclass = Holder - - class ReconfigVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "ReconfigVMRequestType_Holder" - self.pyclass = Holder - - class UpgradeVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpgradeVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpgradeVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._version = None - return - Holder.__name__ = "UpgradeVMRequestType_Holder" - self.pyclass = Holder - - class ExtractOvfEnvironmentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExtractOvfEnvironmentRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExtractOvfEnvironmentRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ExtractOvfEnvironmentRequestType_Holder" - self.pyclass = Holder - - class PowerOnVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PowerOnVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PowerOnVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "PowerOnVMRequestType_Holder" - self.pyclass = Holder - - class PowerOffVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PowerOffVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PowerOffVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "PowerOffVMRequestType_Holder" - self.pyclass = Holder - - class SuspendVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SuspendVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SuspendVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "SuspendVMRequestType_Holder" - self.pyclass = Holder - - class ResetVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ResetVMRequestType_Holder" - self.pyclass = Holder - - class ShutdownGuestRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ShutdownGuestRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ShutdownGuestRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ShutdownGuestRequestType_Holder" - self.pyclass = Holder - - class RebootGuestRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RebootGuestRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RebootGuestRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RebootGuestRequestType_Holder" - self.pyclass = Holder - - class StandbyGuestRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StandbyGuestRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StandbyGuestRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "StandbyGuestRequestType_Holder" - self.pyclass = Holder - - class AnswerVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AnswerVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AnswerVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"questionId"), aname="_questionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"answerChoice"), aname="_answerChoice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._questionId = None - self._answerChoice = None - return - Holder.__name__ = "AnswerVMRequestType_Holder" - self.pyclass = Holder - - class CustomizeVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CustomizeVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CustomizeVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "CustomizeVMRequestType_Holder" - self.pyclass = Holder - - class CheckCustomizationSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckCustomizationSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckCustomizationSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "CheckCustomizationSpecRequestType_Holder" - self.pyclass = Holder - - class MigrateVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MigrateVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MigrateVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMovePriority",lazy=True)(pname=(ns,"priority"), aname="_priority", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._pool = None - self._host = None - self._priority = None - self._state = None - return - Holder.__name__ = "MigrateVMRequestType_Holder" - self.pyclass = Holder - - class RelocateVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RelocateVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RelocateVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMovePriority",lazy=True)(pname=(ns,"priority"), aname="_priority", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - self._priority = None - return - Holder.__name__ = "RelocateVMRequestType_Holder" - self.pyclass = Holder - - class CloneVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CloneVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CloneVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"folder"), aname="_folder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCloneSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._folder = None - self._name = None - self._spec = None - return - Holder.__name__ = "CloneVMRequestType_Holder" - self.pyclass = Holder - - class ExportVmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExportVmRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExportVmRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ExportVmRequestType_Holder" - self.pyclass = Holder - - class MarkAsTemplateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MarkAsTemplateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MarkAsTemplateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "MarkAsTemplateRequestType_Holder" - self.pyclass = Holder - - class MarkAsVirtualMachineRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MarkAsVirtualMachineRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MarkAsVirtualMachineRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._pool = None - self._host = None - return - Holder.__name__ = "MarkAsVirtualMachineRequestType_Holder" - self.pyclass = Holder - - class UnregisterVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UnregisterVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UnregisterVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "UnregisterVMRequestType_Holder" - self.pyclass = Holder - - class ResetGuestInformationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetGuestInformationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetGuestInformationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ResetGuestInformationRequestType_Holder" - self.pyclass = Holder - - class MountToolsInstallerRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MountToolsInstallerRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MountToolsInstallerRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "MountToolsInstallerRequestType_Holder" - self.pyclass = Holder - - class UnmountToolsInstallerRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UnmountToolsInstallerRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UnmountToolsInstallerRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "UnmountToolsInstallerRequestType_Holder" - self.pyclass = Holder - - class UpgradeToolsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpgradeToolsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpgradeToolsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installerOptions"), aname="_installerOptions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._installerOptions = None - return - Holder.__name__ = "UpgradeToolsRequestType_Holder" - self.pyclass = Holder - - class AcquireMksTicketRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AcquireMksTicketRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AcquireMksTicketRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "AcquireMksTicketRequestType_Holder" - self.pyclass = Holder - - class SetScreenResolutionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetScreenResolutionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetScreenResolutionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._width = None - self._height = None - return - Holder.__name__ = "SetScreenResolutionRequestType_Holder" - self.pyclass = Holder - - class DefragmentAllDisksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DefragmentAllDisksRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DefragmentAllDisksRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DefragmentAllDisksRequestType_Holder" - self.pyclass = Holder - - class CreateSecondaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateSecondaryVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateSecondaryVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "CreateSecondaryVMRequestType_Holder" - self.pyclass = Holder - - class TurnOffFaultToleranceForVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "TurnOffFaultToleranceForVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.TurnOffFaultToleranceForVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "TurnOffFaultToleranceForVMRequestType_Holder" - self.pyclass = Holder - - class MakePrimaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MakePrimaryVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.MakePrimaryVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - return - Holder.__name__ = "MakePrimaryVMRequestType_Holder" - self.pyclass = Holder - - class TerminateFaultTolerantVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "TerminateFaultTolerantVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.TerminateFaultTolerantVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - return - Holder.__name__ = "TerminateFaultTolerantVMRequestType_Holder" - self.pyclass = Holder - - class DisableSecondaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DisableSecondaryVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DisableSecondaryVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - return - Holder.__name__ = "DisableSecondaryVMRequestType_Holder" - self.pyclass = Holder - - class EnableSecondaryVMRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EnableSecondaryVMRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.EnableSecondaryVMRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - self._host = None - return - Holder.__name__ = "EnableSecondaryVMRequestType_Holder" - self.pyclass = Holder - - class SetDisplayTopologyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetDisplayTopologyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetDisplayTopologyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDisplayTopology",lazy=True)(pname=(ns,"displays"), aname="_displays", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._displays = [] - return - Holder.__name__ = "SetDisplayTopologyRequestType_Holder" - self.pyclass = Holder - - class StartRecordingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StartRecordingRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StartRecordingRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._description = None - return - Holder.__name__ = "StartRecordingRequestType_Holder" - self.pyclass = Holder - - class StopRecordingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StopRecordingRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StopRecordingRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "StopRecordingRequestType_Holder" - self.pyclass = Holder - - class StartReplayingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StartReplayingRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StartReplayingRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"replaySnapshot"), aname="_replaySnapshot", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._replaySnapshot = None - return - Holder.__name__ = "StartReplayingRequestType_Holder" - self.pyclass = Holder - - class StopReplayingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StopReplayingRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StopReplayingRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "StopReplayingRequestType_Holder" - self.pyclass = Holder - - class PromoteDisksRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PromoteDisksRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PromoteDisksRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unlink"), aname="_unlink", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDisk",lazy=True)(pname=(ns,"disks"), aname="_disks", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._unlink = None - self._disks = [] - return - Holder.__name__ = "PromoteDisksRequestType_Holder" - self.pyclass = Holder - - class CreateScreenshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateScreenshotRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateScreenshotRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "CreateScreenshotRequestType_Holder" - self.pyclass = Holder - - class QueryChangedDiskAreasRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryChangedDiskAreasRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryChangedDiskAreasRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceKey"), aname="_deviceKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"startOffset"), aname="_startOffset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._snapshot = None - self._deviceKey = None - self._startOffset = None - self._changeId = None - return - Holder.__name__ = "QueryChangedDiskAreasRequestType_Holder" - self.pyclass = Holder - - class QueryUnownedFilesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryUnownedFilesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryUnownedFilesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryUnownedFilesRequestType_Holder" - self.pyclass = Holder - - class ActionParameter_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ActionParameter") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class Action_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Action") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Action_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.Action_Def.__bases__: - bases = list(ns0.Action_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.Action_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MethodActionArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MethodActionArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MethodActionArgument_Def.schema - TClist = [ZSI.TC.AnyType(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.MethodActionArgument_Def.__bases__: - bases = list(ns0.MethodActionArgument_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.MethodActionArgument_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfMethodActionArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfMethodActionArgument") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfMethodActionArgument_Def.schema - TClist = [GTD("urn:vim25","MethodActionArgument",lazy=True)(pname=(ns,"MethodActionArgument"), aname="_MethodActionArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._MethodActionArgument = [] - return - Holder.__name__ = "ArrayOfMethodActionArgument_Holder" - self.pyclass = Holder - - class MethodAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MethodAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MethodAction_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","MethodActionArgument",lazy=True)(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Action_Def not in ns0.MethodAction_Def.__bases__: - bases = list(ns0.MethodAction_Def.__bases__) - bases.insert(0, ns0.Action_Def) - ns0.MethodAction_Def.__bases__ = tuple(bases) - - ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SendEmailAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SendEmailAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SendEmailAction_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"toList"), aname="_toList", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ccList"), aname="_ccList", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subject"), aname="_subject", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"body"), aname="_body", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Action_Def not in ns0.SendEmailAction_Def.__bases__: - bases = list(ns0.SendEmailAction_Def.__bases__) - bases.insert(0, ns0.Action_Def) - ns0.SendEmailAction_Def.__bases__ = tuple(bases) - - ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SendSNMPAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SendSNMPAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SendSNMPAction_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Action_Def not in ns0.SendSNMPAction_Def.__bases__: - bases = list(ns0.SendSNMPAction_Def.__bases__) - bases.insert(0, ns0.Action_Def) - ns0.SendSNMPAction_Def.__bases__ = tuple(bases) - - ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RunScriptAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RunScriptAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RunScriptAction_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"script"), aname="_script", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Action_Def not in ns0.RunScriptAction_Def.__bases__: - bases = list(ns0.RunScriptAction_Def.__bases__) - bases.insert(0, ns0.Action_Def) - ns0.RunScriptAction_Def.__bases__ = tuple(bases) - - ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CreateTaskAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CreateTaskAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CreateTaskAction_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"taskTypeId"), aname="_taskTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cancelable"), aname="_cancelable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Action_Def not in ns0.CreateTaskAction_Def.__bases__: - bases = list(ns0.CreateTaskAction_Def.__bases__) - bases.insert(0, ns0.Action_Def) - ns0.CreateTaskAction_Def.__bases__ = tuple(bases) - - ns0.Action_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RemoveAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveAlarmRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveAlarmRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RemoveAlarmRequestType_Holder" - self.pyclass = Holder - - class ReconfigureAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureAlarmRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureAlarmRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "ReconfigureAlarmRequestType_Holder" - self.pyclass = Holder - - class AlarmAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmAction_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AlarmAction_Def.__bases__: - bases = list(ns0.AlarmAction_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AlarmAction_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfAlarmAction_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAlarmAction") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAlarmAction_Def.schema - TClist = [GTD("urn:vim25","AlarmAction",lazy=True)(pname=(ns,"AlarmAction"), aname="_AlarmAction", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._AlarmAction = [] - return - Holder.__name__ = "ArrayOfAlarmAction_Holder" - self.pyclass = Holder - - class AlarmTriggeringActionTransitionSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmTriggeringActionTransitionSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmTriggeringActionTransitionSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"startState"), aname="_startState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"finalState"), aname="_finalState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"repeats"), aname="_repeats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AlarmTriggeringActionTransitionSpec_Def.__bases__: - bases = list(ns0.AlarmTriggeringActionTransitionSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AlarmTriggeringActionTransitionSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfAlarmTriggeringActionTransitionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAlarmTriggeringActionTransitionSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAlarmTriggeringActionTransitionSpec_Def.schema - TClist = [GTD("urn:vim25","AlarmTriggeringActionTransitionSpec",lazy=True)(pname=(ns,"AlarmTriggeringActionTransitionSpec"), aname="_AlarmTriggeringActionTransitionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._AlarmTriggeringActionTransitionSpec = [] - return - Holder.__name__ = "ArrayOfAlarmTriggeringActionTransitionSpec_Holder" - self.pyclass = Holder - - class AlarmTriggeringAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmTriggeringAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmTriggeringAction_Def.schema - TClist = [GTD("urn:vim25","Action",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmTriggeringActionTransitionSpec",lazy=True)(pname=(ns,"transitionSpecs"), aname="_transitionSpecs", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"green2yellow"), aname="_green2yellow", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"yellow2red"), aname="_yellow2red", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"red2yellow"), aname="_red2yellow", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"yellow2green"), aname="_yellow2green", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmAction_Def not in ns0.AlarmTriggeringAction_Def.__bases__: - bases = list(ns0.AlarmTriggeringAction_Def.__bases__) - bases.insert(0, ns0.AlarmAction_Def) - ns0.AlarmTriggeringAction_Def.__bases__ = tuple(bases) - - ns0.AlarmAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GroupAlarmAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GroupAlarmAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GroupAlarmAction_Def.schema - TClist = [GTD("urn:vim25","AlarmAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmAction_Def not in ns0.GroupAlarmAction_Def.__bases__: - bases = list(ns0.GroupAlarmAction_Def.__bases__) - bases.insert(0, ns0.AlarmAction_Def) - ns0.GroupAlarmAction_Def.__bases__ = tuple(bases) - - ns0.AlarmAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmDescription_Def.schema - TClist = [GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"expr"), aname="_expr", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"stateOperator"), aname="_stateOperator", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"metricOperator"), aname="_metricOperator", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"hostSystemConnectionState"), aname="_hostSystemConnectionState", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"virtualMachinePowerState"), aname="_virtualMachinePowerState", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"datastoreConnectionState"), aname="_datastoreConnectionState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"hostSystemPowerState"), aname="_hostSystemPowerState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"virtualMachineGuestHeartbeatStatus"), aname="_virtualMachineGuestHeartbeatStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"entityStatus"), aname="_entityStatus", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AlarmDescription_Def.__bases__: - bases = list(ns0.AlarmDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AlarmDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmExpression_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AlarmExpression_Def.__bases__: - bases = list(ns0.AlarmExpression_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AlarmExpression_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfAlarmExpression_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAlarmExpression") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAlarmExpression_Def.schema - TClist = [GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"AlarmExpression"), aname="_AlarmExpression", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._AlarmExpression = [] - return - Holder.__name__ = "ArrayOfAlarmExpression_Holder" - self.pyclass = Holder - - class AndAlarmExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AndAlarmExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AndAlarmExpression_Def.schema - TClist = [GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmExpression_Def not in ns0.AndAlarmExpression_Def.__bases__: - bases = list(ns0.AndAlarmExpression_Def.__bases__) - bases.insert(0, ns0.AlarmExpression_Def) - ns0.AndAlarmExpression_Def.__bases__ = tuple(bases) - - ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OrAlarmExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OrAlarmExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OrAlarmExpression_Def.schema - TClist = [GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmExpression_Def not in ns0.OrAlarmExpression_Def.__bases__: - bases = list(ns0.OrAlarmExpression_Def.__bases__) - bases.insert(0, ns0.AlarmExpression_Def) - ns0.OrAlarmExpression_Def.__bases__ = tuple(bases) - - ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class StateAlarmOperator_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StateAlarmOperator") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class StateAlarmExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "StateAlarmExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.StateAlarmExpression_Def.schema - TClist = [GTD("urn:vim25","StateAlarmOperator",lazy=True)(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"statePath"), aname="_statePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"yellow"), aname="_yellow", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"red"), aname="_red", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmExpression_Def not in ns0.StateAlarmExpression_Def.__bases__: - bases = list(ns0.StateAlarmExpression_Def.__bases__) - bases.insert(0, ns0.AlarmExpression_Def) - ns0.StateAlarmExpression_Def.__bases__ = tuple(bases) - - ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EventAlarmExpressionComparisonOperator_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EventAlarmExpressionComparisonOperator") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class EventAlarmExpressionComparison_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventAlarmExpressionComparison") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventAlarmExpressionComparison_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"attributeName"), aname="_attributeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventAlarmExpressionComparison_Def.__bases__: - bases = list(ns0.EventAlarmExpressionComparison_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventAlarmExpressionComparison_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfEventAlarmExpressionComparison_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfEventAlarmExpressionComparison") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfEventAlarmExpressionComparison_Def.schema - TClist = [GTD("urn:vim25","EventAlarmExpressionComparison",lazy=True)(pname=(ns,"EventAlarmExpressionComparison"), aname="_EventAlarmExpressionComparison", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._EventAlarmExpressionComparison = [] - return - Holder.__name__ = "ArrayOfEventAlarmExpressionComparison_Holder" - self.pyclass = Holder - - class EventAlarmExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventAlarmExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventAlarmExpression_Def.schema - TClist = [GTD("urn:vim25","EventAlarmExpressionComparison",lazy=True)(pname=(ns,"comparisons"), aname="_comparisons", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventType"), aname="_eventType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectType"), aname="_objectType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmExpression_Def not in ns0.EventAlarmExpression_Def.__bases__: - bases = list(ns0.EventAlarmExpression_Def.__bases__) - bases.insert(0, ns0.AlarmExpression_Def) - ns0.EventAlarmExpression_Def.__bases__ = tuple(bases) - - ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MetricAlarmOperator_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MetricAlarmOperator") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class MetricAlarmExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MetricAlarmExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MetricAlarmExpression_Def.schema - TClist = [GTD("urn:vim25","MetricAlarmOperator",lazy=True)(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"metric"), aname="_metric", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"yellow"), aname="_yellow", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"yellowInterval"), aname="_yellowInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"red"), aname="_red", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"redInterval"), aname="_redInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmExpression_Def not in ns0.MetricAlarmExpression_Def.__bases__: - bases = list(ns0.MetricAlarmExpression_Def.__bases__) - bases.insert(0, ns0.AlarmExpression_Def) - ns0.MetricAlarmExpression_Def.__bases__ = tuple(bases) - - ns0.AlarmExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModifiedTime"), aname="_lastModifiedTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lastModifiedUser"), aname="_lastModifiedUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"creationEventId"), aname="_creationEventId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmSpec_Def not in ns0.AlarmInfo_Def.__bases__: - bases = list(ns0.AlarmInfo_Def.__bases__) - bases.insert(0, ns0.AlarmSpec_Def) - ns0.AlarmInfo_Def.__bases__ = tuple(bases) - - ns0.AlarmSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CreateAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateAlarmRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateAlarmRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._spec = None - return - Holder.__name__ = "CreateAlarmRequestType_Holder" - self.pyclass = Holder - - class GetAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "GetAlarmRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.GetAlarmRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - return - Holder.__name__ = "GetAlarmRequestType_Holder" - self.pyclass = Holder - - class GetAlarmActionsEnabledRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "GetAlarmActionsEnabledRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.GetAlarmActionsEnabledRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - return - Holder.__name__ = "GetAlarmActionsEnabledRequestType_Holder" - self.pyclass = Holder - - class SetAlarmActionsEnabledRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetAlarmActionsEnabledRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetAlarmActionsEnabledRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._enabled = None - return - Holder.__name__ = "SetAlarmActionsEnabledRequestType_Holder" - self.pyclass = Holder - - class GetAlarmStateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "GetAlarmStateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.GetAlarmStateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - return - Holder.__name__ = "GetAlarmStateRequestType_Holder" - self.pyclass = Holder - - class AcknowledgeAlarmRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AcknowledgeAlarmRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AcknowledgeAlarmRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._alarm = None - self._entity = None - return - Holder.__name__ = "AcknowledgeAlarmRequestType_Holder" - self.pyclass = Holder - - class AlarmSetting_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmSetting") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmSetting_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"toleranceRange"), aname="_toleranceRange", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"reportingFrequency"), aname="_reportingFrequency", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AlarmSetting_Def.__bases__: - bases = list(ns0.AlarmSetting_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AlarmSetting_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"actionFrequency"), aname="_actionFrequency", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AlarmSetting",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AlarmSpec_Def.__bases__: - bases = list(ns0.AlarmSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AlarmSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmState_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmState") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmState_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"acknowledged"), aname="_acknowledged", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"acknowledgedByUser"), aname="_acknowledgedByUser", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"acknowledgedTime"), aname="_acknowledgedTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AlarmState_Def.__bases__: - bases = list(ns0.AlarmState_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AlarmState_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfAlarmState_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAlarmState") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAlarmState_Def.schema - TClist = [GTD("urn:vim25","AlarmState",lazy=True)(pname=(ns,"AlarmState"), aname="_AlarmState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._AlarmState = [] - return - Holder.__name__ = "ArrayOfAlarmState_Holder" - self.pyclass = Holder - - class ActionType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ActionType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterAction_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterAction_Def.__bases__: - bases = list(ns0.ClusterAction_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterAction_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterAction_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterAction") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterAction_Def.schema - TClist = [GTD("urn:vim25","ClusterAction",lazy=True)(pname=(ns,"ClusterAction"), aname="_ClusterAction", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterAction = [] - return - Holder.__name__ = "ArrayOfClusterAction_Holder" - self.pyclass = Holder - - class ClusterActionHistory_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterActionHistory") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterActionHistory_Def.schema - TClist = [GTD("urn:vim25","ClusterAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterActionHistory_Def.__bases__: - bases = list(ns0.ClusterActionHistory_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterActionHistory_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterActionHistory_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterActionHistory") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterActionHistory_Def.schema - TClist = [GTD("urn:vim25","ClusterActionHistory",lazy=True)(pname=(ns,"ClusterActionHistory"), aname="_ClusterActionHistory", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterActionHistory = [] - return - Holder.__name__ = "ArrayOfClusterActionHistory_Holder" - self.pyclass = Holder - - class ClusterAffinityRuleSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterAffinityRuleSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterAffinityRuleSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterRuleInfo_Def not in ns0.ClusterAffinityRuleSpec_Def.__bases__: - bases = list(ns0.ClusterAffinityRuleSpec_Def.__bases__) - bases.insert(0, ns0.ClusterRuleInfo_Def) - ns0.ClusterAffinityRuleSpec_Def.__bases__ = tuple(bases) - - ns0.ClusterRuleInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterAntiAffinityRuleSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterAntiAffinityRuleSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterAntiAffinityRuleSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterRuleInfo_Def not in ns0.ClusterAntiAffinityRuleSpec_Def.__bases__: - bases = list(ns0.ClusterAntiAffinityRuleSpec_Def.__bases__) - bases.insert(0, ns0.ClusterRuleInfo_Def) - ns0.ClusterAntiAffinityRuleSpec_Def.__bases__ = tuple(bases) - - ns0.ClusterRuleInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterAttemptedVmInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterAttemptedVmInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterAttemptedVmInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"task"), aname="_task", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterAttemptedVmInfo_Def.__bases__: - bases = list(ns0.ClusterAttemptedVmInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterAttemptedVmInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterAttemptedVmInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterAttemptedVmInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterAttemptedVmInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterAttemptedVmInfo",lazy=True)(pname=(ns,"ClusterAttemptedVmInfo"), aname="_ClusterAttemptedVmInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterAttemptedVmInfo = [] - return - Holder.__name__ = "ArrayOfClusterAttemptedVmInfo_Holder" - self.pyclass = Holder - - class ClusterConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"dasVmConfig"), aname="_dasVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"drsVmConfig"), aname="_drsVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterConfigInfo_Def.__bases__: - bases = list(ns0.ClusterConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsBehavior_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DrsBehavior") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDrsConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDrsConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDrsConfigInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enableVmBehaviorOverrides"), aname="_enableVmBehaviorOverrides", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DrsBehavior",lazy=True)(pname=(ns,"defaultVmBehavior"), aname="_defaultVmBehavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vmotionRate"), aname="_vmotionRate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDrsConfigInfo_Def.__bases__: - bases = list(ns0.ClusterDrsConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDrsConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDrsVmConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDrsVmConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDrsVmConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DrsBehavior",lazy=True)(pname=(ns,"behavior"), aname="_behavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDrsVmConfigInfo_Def.__bases__: - bases = list(ns0.ClusterDrsVmConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDrsVmConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDrsVmConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDrsVmConfigInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDrsVmConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"ClusterDrsVmConfigInfo"), aname="_ClusterDrsVmConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDrsVmConfigInfo = [] - return - Holder.__name__ = "ArrayOfClusterDrsVmConfigInfo_Holder" - self.pyclass = Holder - - class ClusterConfigInfoEx_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterConfigInfoEx") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterConfigInfoEx_Def.schema - TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"dasVmConfig"), aname="_dasVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"drsVmConfig"), aname="_drsVmConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmConfigInfo",lazy=True)(pname=(ns,"dpmConfigInfo"), aname="_dpmConfigInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmHostConfigInfo",lazy=True)(pname=(ns,"dpmHostConfig"), aname="_dpmHostConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ComputeResourceConfigInfo_Def not in ns0.ClusterConfigInfoEx_Def.__bases__: - bases = list(ns0.ClusterConfigInfoEx_Def.__bases__) - bases.insert(0, ns0.ComputeResourceConfigInfo_Def) - ns0.ClusterConfigInfoEx_Def.__bases__ = tuple(bases) - - ns0.ComputeResourceConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DpmBehavior_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DpmBehavior") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDpmConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDpmConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDpmConfigInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DpmBehavior",lazy=True)(pname=(ns,"defaultDpmBehavior"), aname="_defaultDpmBehavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostPowerActionRate"), aname="_hostPowerActionRate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDpmConfigInfo_Def.__bases__: - bases = list(ns0.ClusterDpmConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDpmConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDpmHostConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDpmHostConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDpmHostConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DpmBehavior",lazy=True)(pname=(ns,"behavior"), aname="_behavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDpmHostConfigInfo_Def.__bases__: - bases = list(ns0.ClusterDpmHostConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDpmHostConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDpmHostConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDpmHostConfigInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDpmHostConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterDpmHostConfigInfo",lazy=True)(pname=(ns,"ClusterDpmHostConfigInfo"), aname="_ClusterDpmHostConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDpmHostConfigInfo = [] - return - Holder.__name__ = "ArrayOfClusterDpmHostConfigInfo_Holder" - self.pyclass = Holder - - class ClusterConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigSpec",lazy=True)(pname=(ns,"dasVmConfigSpec"), aname="_dasVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigSpec",lazy=True)(pname=(ns,"drsVmConfigSpec"), aname="_drsVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleSpec",lazy=True)(pname=(ns,"rulesSpec"), aname="_rulesSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterConfigSpec_Def.__bases__: - bases = list(ns0.ClusterConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasVmConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasVmConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasVmConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.ClusterDasVmConfigSpec_Def.__bases__: - bases = list(ns0.ClusterDasVmConfigSpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.ClusterDasVmConfigSpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDasVmConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDasVmConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDasVmConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterDasVmConfigSpec",lazy=True)(pname=(ns,"ClusterDasVmConfigSpec"), aname="_ClusterDasVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDasVmConfigSpec = [] - return - Holder.__name__ = "ArrayOfClusterDasVmConfigSpec_Holder" - self.pyclass = Holder - - class ClusterDrsVmConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDrsVmConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDrsVmConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsVmConfigInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.ClusterDrsVmConfigSpec_Def.__bases__: - bases = list(ns0.ClusterDrsVmConfigSpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.ClusterDrsVmConfigSpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDrsVmConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDrsVmConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDrsVmConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsVmConfigSpec",lazy=True)(pname=(ns,"ClusterDrsVmConfigSpec"), aname="_ClusterDrsVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDrsVmConfigSpec = [] - return - Holder.__name__ = "ArrayOfClusterDrsVmConfigSpec_Holder" - self.pyclass = Holder - - class ClusterRuleSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterRuleSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterRuleSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.ClusterRuleSpec_Def.__bases__: - bases = list(ns0.ClusterRuleSpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.ClusterRuleSpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterRuleSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterRuleSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterRuleSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterRuleSpec",lazy=True)(pname=(ns,"ClusterRuleSpec"), aname="_ClusterRuleSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterRuleSpec = [] - return - Holder.__name__ = "ArrayOfClusterRuleSpec_Holder" - self.pyclass = Holder - - class ClusterConfigSpecEx_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterConfigSpecEx") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterConfigSpecEx_Def.schema - TClist = [GTD("urn:vim25","ClusterDasConfigInfo",lazy=True)(pname=(ns,"dasConfig"), aname="_dasConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmConfigSpec",lazy=True)(pname=(ns,"dasVmConfigSpec"), aname="_dasVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsConfigInfo",lazy=True)(pname=(ns,"drsConfig"), aname="_drsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsVmConfigSpec",lazy=True)(pname=(ns,"drsVmConfigSpec"), aname="_drsVmConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleSpec",lazy=True)(pname=(ns,"rulesSpec"), aname="_rulesSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmConfigInfo",lazy=True)(pname=(ns,"dpmConfig"), aname="_dpmConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDpmHostConfigSpec",lazy=True)(pname=(ns,"dpmHostConfigSpec"), aname="_dpmHostConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ComputeResourceConfigSpec_Def not in ns0.ClusterConfigSpecEx_Def.__bases__: - bases = list(ns0.ClusterConfigSpecEx_Def.__bases__) - bases.insert(0, ns0.ComputeResourceConfigSpec_Def) - ns0.ClusterConfigSpecEx_Def.__bases__ = tuple(bases) - - ns0.ComputeResourceConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDpmHostConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDpmHostConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDpmHostConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterDpmHostConfigInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.ClusterDpmHostConfigSpec_Def.__bases__: - bases = list(ns0.ClusterDpmHostConfigSpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.ClusterDpmHostConfigSpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDpmHostConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDpmHostConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDpmHostConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ClusterDpmHostConfigSpec",lazy=True)(pname=(ns,"ClusterDpmHostConfigSpec"), aname="_ClusterDpmHostConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDpmHostConfigSpec = [] - return - Holder.__name__ = "ArrayOfClusterDpmHostConfigSpec_Holder" - self.pyclass = Holder - - class ClusterDasAamHostInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasAamHostInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasAamHostInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterDasAamNodeState",lazy=True)(pname=(ns,"hostDasState"), aname="_hostDasState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"primaryHosts"), aname="_primaryHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasHostInfo_Def not in ns0.ClusterDasAamHostInfo_Def.__bases__: - bases = list(ns0.ClusterDasAamHostInfo_Def.__bases__) - bases.insert(0, ns0.ClusterDasHostInfo_Def) - ns0.ClusterDasAamHostInfo_Def.__bases__ = tuple(bases) - - ns0.ClusterDasHostInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasAamNodeStateDasState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ClusterDasAamNodeStateDasState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDasAamNodeState_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasAamNodeState") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasAamNodeState_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configState"), aname="_configState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"runtimeState"), aname="_runtimeState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasAamNodeState_Def.__bases__: - bases = list(ns0.ClusterDasAamNodeState_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasAamNodeState_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDasAamNodeState_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDasAamNodeState") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDasAamNodeState_Def.schema - TClist = [GTD("urn:vim25","ClusterDasAamNodeState",lazy=True)(pname=(ns,"ClusterDasAamNodeState"), aname="_ClusterDasAamNodeState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDasAamNodeState = [] - return - Holder.__name__ = "ArrayOfClusterDasAamNodeState_Holder" - self.pyclass = Holder - - class ClusterDasAdmissionControlInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasAdmissionControlInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasAdmissionControlInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasAdmissionControlInfo_Def.__bases__: - bases = list(ns0.ClusterDasAdmissionControlInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasAdmissionControlInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasAdmissionControlPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasAdmissionControlPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasAdmissionControlPolicy_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasAdmissionControlPolicy_Def.__bases__: - bases = list(ns0.ClusterDasAdmissionControlPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasAdmissionControlPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasAdvancedRuntimeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasAdvancedRuntimeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasAdvancedRuntimeInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterDasHostInfo",lazy=True)(pname=(ns,"dasHostInfo"), aname="_dasHostInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasAdvancedRuntimeInfo_Def.__bases__: - bases = list(ns0.ClusterDasAdvancedRuntimeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasAdvancedRuntimeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasConfigInfoServiceState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ClusterDasConfigInfoServiceState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDasConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasConfigInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmMonitoring"), aname="_vmMonitoring", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostMonitoring"), aname="_hostMonitoring", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"failoverLevel"), aname="_failoverLevel", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasAdmissionControlPolicy",lazy=True)(pname=(ns,"admissionControlPolicy"), aname="_admissionControlPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"admissionControlEnabled"), aname="_admissionControlEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmSettings",lazy=True)(pname=(ns,"defaultVmSettings"), aname="_defaultVmSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasConfigInfo_Def.__bases__: - bases = list(ns0.ClusterDasConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numVcpus"), aname="_numVcpus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuMHz"), aname="_cpuMHz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.__bases__: - bases = list(ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"slots"), aname="_slots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.__bases__: - bases = list(ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Def.schema - TClist = [GTD("urn:vim25","ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots",lazy=True)(pname=(ns,"ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots"), aname="_ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots = [] - return - Holder.__name__ = "ArrayOfClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots_Holder" - self.pyclass = Holder - - class ClusterDasFailoverLevelAdvancedRuntimeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasFailoverLevelAdvancedRuntimeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo",lazy=True)(pname=(ns,"slotInfo"), aname="_slotInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalSlots"), aname="_totalSlots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"usedSlots"), aname="_usedSlots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"unreservedSlots"), aname="_unreservedSlots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalVms"), aname="_totalVms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalHosts"), aname="_totalHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalGoodHosts"), aname="_totalGoodHosts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots",lazy=True)(pname=(ns,"hostSlots"), aname="_hostSlots", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasAdvancedRuntimeInfo_Def not in ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.__bases__: - bases = list(ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.__bases__) - bases.insert(0, ns0.ClusterDasAdvancedRuntimeInfo_Def) - ns0.ClusterDasFailoverLevelAdvancedRuntimeInfo_Def.__bases__ = tuple(bases) - - ns0.ClusterDasAdvancedRuntimeInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasHostInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasHostInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasHostInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasHostInfo_Def.__bases__: - bases = list(ns0.ClusterDasHostInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasHostInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDasHostRecommendation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasHostRecommendation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasHostRecommendation_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"drsRating"), aname="_drsRating", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasHostRecommendation_Def.__bases__: - bases = list(ns0.ClusterDasHostRecommendation_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasHostRecommendation_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasVmPriority_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DasVmPriority") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDasVmConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasVmConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasVmConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DasVmPriority",lazy=True)(pname=(ns,"restartPriority"), aname="_restartPriority", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"powerOffOnIsolation"), aname="_powerOffOnIsolation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDasVmSettings",lazy=True)(pname=(ns,"dasSettings"), aname="_dasSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasVmConfigInfo_Def.__bases__: - bases = list(ns0.ClusterDasVmConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasVmConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDasVmConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDasVmConfigInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDasVmConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterDasVmConfigInfo",lazy=True)(pname=(ns,"ClusterDasVmConfigInfo"), aname="_ClusterDasVmConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDasVmConfigInfo = [] - return - Holder.__name__ = "ArrayOfClusterDasVmConfigInfo_Holder" - self.pyclass = Holder - - class ClusterDasVmSettingsRestartPriority_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ClusterDasVmSettingsRestartPriority") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDasVmSettingsIsolationResponse_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ClusterDasVmSettingsIsolationResponse") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDasVmSettings_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDasVmSettings") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDasVmSettings_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"restartPriority"), aname="_restartPriority", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"isolationResponse"), aname="_isolationResponse", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterVmToolsMonitoringSettings",lazy=True)(pname=(ns,"vmToolsMonitoringSettings"), aname="_vmToolsMonitoringSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDasVmSettings_Def.__bases__: - bases = list(ns0.ClusterDasVmSettings_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDasVmSettings_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDrsFaultsFaultsByVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDrsFaultsFaultsByVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDrsFaultsFaultsByVm_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDrsFaultsFaultsByVm_Def.__bases__: - bases = list(ns0.ClusterDrsFaultsFaultsByVm_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDrsFaultsFaultsByVm_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDrsFaultsFaultsByVm_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDrsFaultsFaultsByVm") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDrsFaultsFaultsByVm_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsFaultsFaultsByVm",lazy=True)(pname=(ns,"ClusterDrsFaultsFaultsByVm"), aname="_ClusterDrsFaultsFaultsByVm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDrsFaultsFaultsByVm = [] - return - Holder.__name__ = "ArrayOfClusterDrsFaultsFaultsByVm_Holder" - self.pyclass = Holder - - class ClusterDrsFaults_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDrsFaults") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDrsFaults_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsFaultsFaultsByVm",lazy=True)(pname=(ns,"faultsByVm"), aname="_faultsByVm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDrsFaults_Def.__bases__: - bases = list(ns0.ClusterDrsFaults_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDrsFaults_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDrsFaults_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDrsFaults") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDrsFaults_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsFaults",lazy=True)(pname=(ns,"ClusterDrsFaults"), aname="_ClusterDrsFaults", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDrsFaults = [] - return - Holder.__name__ = "ArrayOfClusterDrsFaults_Holder" - self.pyclass = Holder - - class ClusterDrsMigration_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDrsMigration") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDrsMigration_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuLoad"), aname="_cpuLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryLoad"), aname="_memoryLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"sourceCpuLoad"), aname="_sourceCpuLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"sourceMemoryLoad"), aname="_sourceMemoryLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destination"), aname="_destination", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"destinationCpuLoad"), aname="_destinationCpuLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"destinationMemoryLoad"), aname="_destinationMemoryLoad", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDrsMigration_Def.__bases__: - bases = list(ns0.ClusterDrsMigration_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDrsMigration_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDrsMigration_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDrsMigration") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDrsMigration_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsMigration",lazy=True)(pname=(ns,"ClusterDrsMigration"), aname="_ClusterDrsMigration", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDrsMigration = [] - return - Holder.__name__ = "ArrayOfClusterDrsMigration_Holder" - self.pyclass = Holder - - class DrsRecommendationReasonCode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DrsRecommendationReasonCode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterDrsRecommendation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDrsRecommendation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDrsRecommendation_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"rating"), aname="_rating", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reasonText"), aname="_reasonText", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterDrsMigration",lazy=True)(pname=(ns,"migrationList"), aname="_migrationList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterDrsRecommendation_Def.__bases__: - bases = list(ns0.ClusterDrsRecommendation_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterDrsRecommendation_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterDrsRecommendation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterDrsRecommendation") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterDrsRecommendation_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsRecommendation",lazy=True)(pname=(ns,"ClusterDrsRecommendation"), aname="_ClusterDrsRecommendation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterDrsRecommendation = [] - return - Holder.__name__ = "ArrayOfClusterDrsRecommendation_Holder" - self.pyclass = Holder - - class ClusterFailoverHostAdmissionControlInfoHostStatus_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterFailoverHostAdmissionControlInfoHostStatus") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.__bases__: - bases = list(ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterFailoverHostAdmissionControlInfoHostStatus_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus_Def.schema - TClist = [GTD("urn:vim25","ClusterFailoverHostAdmissionControlInfoHostStatus",lazy=True)(pname=(ns,"ClusterFailoverHostAdmissionControlInfoHostStatus"), aname="_ClusterFailoverHostAdmissionControlInfoHostStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterFailoverHostAdmissionControlInfoHostStatus = [] - return - Holder.__name__ = "ArrayOfClusterFailoverHostAdmissionControlInfoHostStatus_Holder" - self.pyclass = Holder - - class ClusterFailoverHostAdmissionControlInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterFailoverHostAdmissionControlInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterFailoverHostAdmissionControlInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterFailoverHostAdmissionControlInfoHostStatus",lazy=True)(pname=(ns,"hostStatus"), aname="_hostStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasAdmissionControlInfo_Def not in ns0.ClusterFailoverHostAdmissionControlInfo_Def.__bases__: - bases = list(ns0.ClusterFailoverHostAdmissionControlInfo_Def.__bases__) - bases.insert(0, ns0.ClusterDasAdmissionControlInfo_Def) - ns0.ClusterFailoverHostAdmissionControlInfo_Def.__bases__ = tuple(bases) - - ns0.ClusterDasAdmissionControlInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterFailoverHostAdmissionControlPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterFailoverHostAdmissionControlPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterFailoverHostAdmissionControlPolicy_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"failoverHosts"), aname="_failoverHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasAdmissionControlPolicy_Def not in ns0.ClusterFailoverHostAdmissionControlPolicy_Def.__bases__: - bases = list(ns0.ClusterFailoverHostAdmissionControlPolicy_Def.__bases__) - bases.insert(0, ns0.ClusterDasAdmissionControlPolicy_Def) - ns0.ClusterFailoverHostAdmissionControlPolicy_Def.__bases__ = tuple(bases) - - ns0.ClusterDasAdmissionControlPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterFailoverLevelAdmissionControlInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterFailoverLevelAdmissionControlInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterFailoverLevelAdmissionControlInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"currentFailoverLevel"), aname="_currentFailoverLevel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasAdmissionControlInfo_Def not in ns0.ClusterFailoverLevelAdmissionControlInfo_Def.__bases__: - bases = list(ns0.ClusterFailoverLevelAdmissionControlInfo_Def.__bases__) - bases.insert(0, ns0.ClusterDasAdmissionControlInfo_Def) - ns0.ClusterFailoverLevelAdmissionControlInfo_Def.__bases__ = tuple(bases) - - ns0.ClusterDasAdmissionControlInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterFailoverLevelAdmissionControlPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterFailoverLevelAdmissionControlPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"failoverLevel"), aname="_failoverLevel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasAdmissionControlPolicy_Def not in ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.__bases__: - bases = list(ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.__bases__) - bases.insert(0, ns0.ClusterDasAdmissionControlPolicy_Def) - ns0.ClusterFailoverLevelAdmissionControlPolicy_Def.__bases__ = tuple(bases) - - ns0.ClusterDasAdmissionControlPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterFailoverResourcesAdmissionControlInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterFailoverResourcesAdmissionControlInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"currentCpuFailoverResourcesPercent"), aname="_currentCpuFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"currentMemoryFailoverResourcesPercent"), aname="_currentMemoryFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasAdmissionControlInfo_Def not in ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.__bases__: - bases = list(ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.__bases__) - bases.insert(0, ns0.ClusterDasAdmissionControlInfo_Def) - ns0.ClusterFailoverResourcesAdmissionControlInfo_Def.__bases__ = tuple(bases) - - ns0.ClusterDasAdmissionControlInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterFailoverResourcesAdmissionControlPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterFailoverResourcesAdmissionControlPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"cpuFailoverResourcesPercent"), aname="_cpuFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryFailoverResourcesPercent"), aname="_memoryFailoverResourcesPercent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterDasAdmissionControlPolicy_Def not in ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.__bases__: - bases = list(ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.__bases__) - bases.insert(0, ns0.ClusterDasAdmissionControlPolicy_Def) - ns0.ClusterFailoverResourcesAdmissionControlPolicy_Def.__bases__ = tuple(bases) - - ns0.ClusterDasAdmissionControlPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostPowerOperationType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostPowerOperationType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterHostPowerAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterHostPowerAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterHostPowerAction_Def.schema - TClist = [GTD("urn:vim25","HostPowerOperationType",lazy=True)(pname=(ns,"operationType"), aname="_operationType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"powerConsumptionWatt"), aname="_powerConsumptionWatt", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuCapacityMHz"), aname="_cpuCapacityMHz", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memCapacityMB"), aname="_memCapacityMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterAction_Def not in ns0.ClusterHostPowerAction_Def.__bases__: - bases = list(ns0.ClusterHostPowerAction_Def.__bases__) - bases.insert(0, ns0.ClusterAction_Def) - ns0.ClusterHostPowerAction_Def.__bases__ = tuple(bases) - - ns0.ClusterAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterHostRecommendation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterHostRecommendation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterHostRecommendation_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"rating"), aname="_rating", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterHostRecommendation_Def.__bases__: - bases = list(ns0.ClusterHostRecommendation_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterHostRecommendation_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterHostRecommendation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterHostRecommendation") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterHostRecommendation_Def.schema - TClist = [GTD("urn:vim25","ClusterHostRecommendation",lazy=True)(pname=(ns,"ClusterHostRecommendation"), aname="_ClusterHostRecommendation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterHostRecommendation = [] - return - Holder.__name__ = "ArrayOfClusterHostRecommendation_Holder" - self.pyclass = Holder - - class ClusterInitialPlacementAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterInitialPlacementAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterInitialPlacementAction_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"targetHost"), aname="_targetHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterAction_Def not in ns0.ClusterInitialPlacementAction_Def.__bases__: - bases = list(ns0.ClusterInitialPlacementAction_Def.__bases__) - bases.insert(0, ns0.ClusterAction_Def) - ns0.ClusterInitialPlacementAction_Def.__bases__ = tuple(bases) - - ns0.ClusterAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterMigrationAction_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterMigrationAction") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterMigrationAction_Def.schema - TClist = [GTD("urn:vim25","ClusterDrsMigration",lazy=True)(pname=(ns,"drsMigration"), aname="_drsMigration", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterAction_Def not in ns0.ClusterMigrationAction_Def.__bases__: - bases = list(ns0.ClusterMigrationAction_Def.__bases__) - bases.insert(0, ns0.ClusterAction_Def) - ns0.ClusterMigrationAction_Def.__bases__ = tuple(bases) - - ns0.ClusterAction_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterNotAttemptedVmInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterNotAttemptedVmInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterNotAttemptedVmInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterNotAttemptedVmInfo_Def.__bases__: - bases = list(ns0.ClusterNotAttemptedVmInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterNotAttemptedVmInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterNotAttemptedVmInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterNotAttemptedVmInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterNotAttemptedVmInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterNotAttemptedVmInfo",lazy=True)(pname=(ns,"ClusterNotAttemptedVmInfo"), aname="_ClusterNotAttemptedVmInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterNotAttemptedVmInfo = [] - return - Holder.__name__ = "ArrayOfClusterNotAttemptedVmInfo_Holder" - self.pyclass = Holder - - class ClusterPowerOnVmResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterPowerOnVmResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterPowerOnVmResult_Def.schema - TClist = [GTD("urn:vim25","ClusterAttemptedVmInfo",lazy=True)(pname=(ns,"attempted"), aname="_attempted", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterNotAttemptedVmInfo",lazy=True)(pname=(ns,"notAttempted"), aname="_notAttempted", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRecommendation",lazy=True)(pname=(ns,"recommendations"), aname="_recommendations", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterPowerOnVmResult_Def.__bases__: - bases = list(ns0.ClusterPowerOnVmResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterPowerOnVmResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RecommendationType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RecommendationType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class RecommendationReasonCode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RecommendationReasonCode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterRecommendation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterRecommendation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterRecommendation_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"time"), aname="_time", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"rating"), aname="_rating", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reasonText"), aname="_reasonText", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"prerequisite"), aname="_prerequisite", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterAction",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterRecommendation_Def.__bases__: - bases = list(ns0.ClusterRecommendation_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterRecommendation_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterRecommendation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterRecommendation") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterRecommendation_Def.schema - TClist = [GTD("urn:vim25","ClusterRecommendation",lazy=True)(pname=(ns,"ClusterRecommendation"), aname="_ClusterRecommendation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterRecommendation = [] - return - Holder.__name__ = "ArrayOfClusterRecommendation_Holder" - self.pyclass = Holder - - class ClusterRuleInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterRuleInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterRuleInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterRuleInfo_Def.__bases__: - bases = list(ns0.ClusterRuleInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterRuleInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfClusterRuleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfClusterRuleInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfClusterRuleInfo_Def.schema - TClist = [GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"ClusterRuleInfo"), aname="_ClusterRuleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ClusterRuleInfo = [] - return - Holder.__name__ = "ArrayOfClusterRuleInfo_Holder" - self.pyclass = Holder - - class ClusterVmToolsMonitoringSettings_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterVmToolsMonitoringSettings") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterVmToolsMonitoringSettings_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"clusterSettings"), aname="_clusterSettings", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"failureInterval"), aname="_failureInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"minUpTime"), aname="_minUpTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxFailures"), aname="_maxFailures", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxFailureWindow"), aname="_maxFailureWindow", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ClusterVmToolsMonitoringSettings_Def.__bases__: - bases = list(ns0.ClusterVmToolsMonitoringSettings_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ClusterVmToolsMonitoringSettings_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortConfigSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortConfigSpec_Def.__bases__: - bases = list(ns0.DVPortConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDVPortConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDVPortConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDVPortConfigSpec_Def.schema - TClist = [GTD("urn:vim25","DVPortConfigSpec",lazy=True)(pname=(ns,"DVPortConfigSpec"), aname="_DVPortConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DVPortConfigSpec = [] - return - Holder.__name__ = "ArrayOfDVPortConfigSpec_Holder" - self.pyclass = Holder - - class DVPortConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortConfigInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"setting"), aname="_setting", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortConfigInfo_Def.__bases__: - bases = list(ns0.DVPortConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSTrafficShapingPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSTrafficShapingPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSTrafficShapingPolicy_Def.schema - TClist = [GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongPolicy",lazy=True)(pname=(ns,"averageBandwidth"), aname="_averageBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongPolicy",lazy=True)(pname=(ns,"peakBandwidth"), aname="_peakBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongPolicy",lazy=True)(pname=(ns,"burstSize"), aname="_burstSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.DVSTrafficShapingPolicy_Def.__bases__: - bases = list(ns0.DVSTrafficShapingPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.DVSTrafficShapingPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSVendorSpecificConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSVendorSpecificConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSVendorSpecificConfig_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"keyValue"), aname="_keyValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.DVSVendorSpecificConfig_Def.__bases__: - bases = list(ns0.DVSVendorSpecificConfig_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.DVSVendorSpecificConfig_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortSetting_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortSetting") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortSetting_Def.schema - TClist = [GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"blocked"), aname="_blocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSTrafficShapingPolicy",lazy=True)(pname=(ns,"inShapingPolicy"), aname="_inShapingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSTrafficShapingPolicy",lazy=True)(pname=(ns,"outShapingPolicy"), aname="_outShapingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSVendorSpecificConfig",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortSetting_Def.__bases__: - bases = list(ns0.DVPortSetting_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortSetting_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortStatus_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortStatus") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortStatus_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"linkUp"), aname="_linkUp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"blocked"), aname="_blocked", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NumericRange",lazy=True)(pname=(ns,"vlanIds"), aname="_vlanIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"trunkingMode"), aname="_trunkingMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"linkPeer"), aname="_linkPeer", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortStatus_Def.__bases__: - bases = list(ns0.DVPortStatus_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortStatus_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortState_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortState") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortState_Def.schema - TClist = [GTD("urn:vim25","DVPortStatus",lazy=True)(pname=(ns,"runtimeInfo"), aname="_runtimeInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortStatistics",lazy=True)(pname=(ns,"stats"), aname="_stats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificState"), aname="_vendorSpecificState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortState_Def.__bases__: - bases = list(ns0.DVPortState_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortState_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualPort_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualPort") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualPort_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortConfigInfo",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dvsUuid"), aname="_dvsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"proxyHost"), aname="_proxyHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnectee",lazy=True)(pname=(ns,"connectee"), aname="_connectee", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"conflict"), aname="_conflict", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"conflictPortKey"), aname="_conflictPortKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"connectionCookie"), aname="_connectionCookie", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastStatusChange"), aname="_lastStatusChange", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualPort_Def.__bases__: - bases = list(ns0.DistributedVirtualPort_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualPort_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualPort_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualPort") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualPort_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualPort",lazy=True)(pname=(ns,"DistributedVirtualPort"), aname="_DistributedVirtualPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualPort = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualPort_Holder" - self.pyclass = Holder - - class DistributedVirtualPortgroupPortgroupType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DistributedVirtualPortgroupPortgroupType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DVPortgroupPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupPolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"blockOverrideAllowed"), aname="_blockOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shapingOverrideAllowed"), aname="_shapingOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vendorConfigOverrideAllowed"), aname="_vendorConfigOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"livePortMovingAllowed"), aname="_livePortMovingAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"portConfigResetAtDisconnect"), aname="_portConfigResetAtDisconnect", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortgroupPolicy_Def.__bases__: - bases = list(ns0.DVPortgroupPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortgroupPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualPortgroupMetaTagName_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DistributedVirtualPortgroupMetaTagName") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DVPortgroupConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupConfigSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portNameFormat"), aname="_portNameFormat", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortgroupConfigSpec_Def.__bases__: - bases = list(ns0.DVPortgroupConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortgroupConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDVPortgroupConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDVPortgroupConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDVPortgroupConfigSpec_Def.schema - TClist = [GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"DVPortgroupConfigSpec"), aname="_DVPortgroupConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DVPortgroupConfigSpec = [] - return - Holder.__name__ = "ArrayOfDVPortgroupConfigSpec_Holder" - self.pyclass = Holder - - class DVPortgroupConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupConfigInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortSetting",lazy=True)(pname=(ns,"defaultPortConfig"), aname="_defaultPortConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portNameFormat"), aname="_portNameFormat", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVPortgroupConfigInfo_Def.__bases__: - bases = list(ns0.DVPortgroupConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVPortgroupConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortgroupReconfigureRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVPortgroupReconfigureRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVPortgroupReconfigureRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "DVPortgroupReconfigureRequestType_Holder" - self.pyclass = Holder - - class DistributedVirtualPortgroupInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualPortgroupInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualPortgroupInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"switchName"), aname="_switchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupType"), aname="_portgroupType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uplinkPortgroup"), aname="_uplinkPortgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualPortgroupInfo_Def.__bases__: - bases = list(ns0.DistributedVirtualPortgroupInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualPortgroupInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualPortgroupInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualPortgroupInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualPortgroupInfo_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualPortgroupInfo",lazy=True)(pname=(ns,"DistributedVirtualPortgroupInfo"), aname="_DistributedVirtualPortgroupInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualPortgroupInfo = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualPortgroupInfo_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"switchName"), aname="_switchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchInfo_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualSwitchInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualSwitchInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualSwitchInfo_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchInfo",lazy=True)(pname=(ns,"DistributedVirtualSwitchInfo"), aname="_DistributedVirtualSwitchInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualSwitchInfo = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualSwitchInfo_Holder" - self.pyclass = Holder - - class DVSManagerDvsConfigTarget_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSManagerDvsConfigTarget") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSManagerDvsConfigTarget_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualPortgroupInfo",lazy=True)(pname=(ns,"distributedVirtualPortgroup"), aname="_distributedVirtualPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchInfo",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DVSManagerDvsConfigTarget_Def.__bases__: - bases = list(ns0.DVSManagerDvsConfigTarget_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DVSManagerDvsConfigTarget_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSManagerQueryAvailableSwitchSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSManagerQueryAvailableSwitchSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DVSManagerQueryAvailableSwitchSpecRequestType_Holder" - self.pyclass = Holder - - class DVSManagerQueryCompatibleHostForNewDvsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSManagerQueryCompatibleHostForNewDvsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"container"), aname="_container", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recursive"), aname="_recursive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"switchProductSpec"), aname="_switchProductSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._container = None - self._recursive = None - self._switchProductSpec = None - return - Holder.__name__ = "DVSManagerQueryCompatibleHostForNewDvsRequestType_Holder" - self.pyclass = Holder - - class DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSManagerQueryCompatibleHostForExistingDvsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"container"), aname="_container", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recursive"), aname="_recursive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._container = None - self._recursive = None - self._dvs = None - return - Holder.__name__ = "DVSManagerQueryCompatibleHostForExistingDvsRequestType_Holder" - self.pyclass = Holder - - class DVSManagerQueryCompatibleHostSpecRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSManagerQueryCompatibleHostSpecRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"switchProductSpec"), aname="_switchProductSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._switchProductSpec = None - return - Holder.__name__ = "DVSManagerQueryCompatibleHostSpecRequestType_Holder" - self.pyclass = Holder - - class DVSManagerQuerySwitchByUuidRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSManagerQuerySwitchByUuidRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSManagerQuerySwitchByUuidRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._uuid = None - return - Holder.__name__ = "DVSManagerQuerySwitchByUuidRequestType_Holder" - self.pyclass = Holder - - class DVSManagerQueryDvsConfigTargetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DVSManagerQueryDvsConfigTargetRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DVSManagerQueryDvsConfigTargetRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._dvs = None - return - Holder.__name__ = "DVSManagerQueryDvsConfigTargetRequestType_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchHostMemberHostComponentState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostMemberHostComponentState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DistributedVirtualSwitchHostMemberConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostMemberConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMemberBacking",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxProxySwitchPorts"), aname="_maxProxySwitchPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchHostMemberConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualSwitchHostMemberConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualSwitchHostMemberConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualSwitchHostMemberConfigSpec_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberConfigSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostMemberConfigSpec"), aname="_DistributedVirtualSwitchHostMemberConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualSwitchHostMemberConfigSpec = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostMemberConfigSpec_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchHostMemberPnicSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostMemberPnicSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"pnicDevice"), aname="_pnicDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uplinkPortKey"), aname="_uplinkPortKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uplinkPortgroupKey"), aname="_uplinkPortgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"connectionCookie"), aname="_connectionCookie", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchHostMemberPnicSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualSwitchHostMemberPnicSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualSwitchHostMemberPnicSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualSwitchHostMemberPnicSpec_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberPnicSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostMemberPnicSpec"), aname="_DistributedVirtualSwitchHostMemberPnicSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualSwitchHostMemberPnicSpec = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostMemberPnicSpec_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchHostMemberBacking_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostMemberBacking") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchHostMemberBacking_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberBacking_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchHostMemberBacking_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchHostMemberBacking_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualSwitchHostMemberPnicBacking_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostMemberPnicBacking") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberPnicSpec",lazy=True)(pname=(ns,"pnicSpec"), aname="_pnicSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DistributedVirtualSwitchHostMemberBacking_Def not in ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.__bases__) - bases.insert(0, ns0.DistributedVirtualSwitchHostMemberBacking_Def) - ns0.DistributedVirtualSwitchHostMemberPnicBacking_Def.__bases__ = tuple(bases) - - ns0.DistributedVirtualSwitchHostMemberBacking_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualSwitchHostMemberConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostMemberConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxProxySwitchPorts"), aname="_maxProxySwitchPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"vendorSpecificConfig"), aname="_vendorSpecificConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchHostMemberBacking",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchHostMemberConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualSwitchHostMember_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostMember") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchHostMember_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberConfigInfo",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uplinkPortKey"), aname="_uplinkPortKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostMember_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchHostMember_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchHostMember_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualSwitchHostMember_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualSwitchHostMember") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualSwitchHostMember_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMember",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostMember"), aname="_DistributedVirtualSwitchHostMember", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualSwitchHostMember = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostMember_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchHostProductSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchHostProductSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchHostProductSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"productLineId"), aname="_productLineId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchHostProductSpec_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchHostProductSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchHostProductSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualSwitchHostProductSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualSwitchHostProductSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualSwitchHostProductSpec_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostProductSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchHostProductSpec"), aname="_DistributedVirtualSwitchHostProductSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualSwitchHostProductSpec = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualSwitchHostProductSpec_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchKeyedOpaqueBlob_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchKeyedOpaqueBlob") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"opaqueData"), aname="_opaqueData", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchKeyedOpaqueBlob_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchKeyedOpaqueBlob",lazy=True)(pname=(ns,"DistributedVirtualSwitchKeyedOpaqueBlob"), aname="_DistributedVirtualSwitchKeyedOpaqueBlob", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualSwitchKeyedOpaqueBlob = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualSwitchKeyedOpaqueBlob_Holder" - self.pyclass = Holder - - class DistributedVirtualSwitchPortConnecteeConnecteeType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchPortConnecteeConnecteeType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DistributedVirtualSwitchPortConnectee_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchPortConnectee") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchPortConnectee_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"connectedEntity"), aname="_connectedEntity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicKey"), aname="_nicKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"addressHint"), aname="_addressHint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortConnectee_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchPortConnectee_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchPortConnectee_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualSwitchPortConnection_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchPortConnection") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchPortConnection_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"connectionCookie"), aname="_connectionCookie", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortConnection_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchPortConnection_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchPortConnection_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualSwitchPortCriteria_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchPortCriteria") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchPortCriteria_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"active"), aname="_active", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uplinkPort"), aname="_uplinkPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inside"), aname="_inside", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortCriteria_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchPortCriteria_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchPortCriteria_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualSwitchPortStatistics_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchPortStatistics") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchPortStatistics_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"packetsInMulticast"), aname="_packetsInMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutMulticast"), aname="_packetsOutMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesInMulticast"), aname="_bytesInMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesOutMulticast"), aname="_bytesOutMulticast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInUnicast"), aname="_packetsInUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutUnicast"), aname="_packetsOutUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesInUnicast"), aname="_bytesInUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesOutUnicast"), aname="_bytesOutUnicast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInBroadcast"), aname="_packetsInBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutBroadcast"), aname="_packetsOutBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesInBroadcast"), aname="_bytesInBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"bytesOutBroadcast"), aname="_bytesOutBroadcast", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInDropped"), aname="_packetsInDropped", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutDropped"), aname="_packetsOutDropped", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsInException"), aname="_packetsInException", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"packetsOutException"), aname="_packetsOutException", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchPortStatistics_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchPortStatistics_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchPortStatistics_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DistributedVirtualSwitchProductSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DistributedVirtualSwitchProductSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DistributedVirtualSwitchProductSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"build"), aname="_build", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"forwardingClass"), aname="_forwardingClass", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleId"), aname="_bundleId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrl"), aname="_bundleUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DistributedVirtualSwitchProductSpec_Def.__bases__: - bases = list(ns0.DistributedVirtualSwitchProductSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DistributedVirtualSwitchProductSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDistributedVirtualSwitchProductSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDistributedVirtualSwitchProductSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDistributedVirtualSwitchProductSpec_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"DistributedVirtualSwitchProductSpec"), aname="_DistributedVirtualSwitchProductSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DistributedVirtualSwitchProductSpec = [] - return - Holder.__name__ = "ArrayOfDistributedVirtualSwitchProductSpec_Holder" - self.pyclass = Holder - - class VMwareDVSConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMwareDVSConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMwareDVSConfigInfo_Def.schema - TClist = [GTD("urn:vim25","VMwareDVSPvlanMapEntry",lazy=True)(pname=(ns,"pvlanConfig"), aname="_pvlanConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMtu"), aname="_maxMtu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkDiscoveryProtocolConfig",lazy=True)(pname=(ns,"linkDiscoveryProtocolConfig"), aname="_linkDiscoveryProtocolConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVSConfigInfo_Def not in ns0.VMwareDVSConfigInfo_Def.__bases__: - bases = list(ns0.VMwareDVSConfigInfo_Def.__bases__) - bases.insert(0, ns0.DVSConfigInfo_Def) - ns0.VMwareDVSConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DVSConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMwareDVSConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMwareDVSConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMwareDVSConfigSpec_Def.schema - TClist = [GTD("urn:vim25","VMwareDVSPvlanConfigSpec",lazy=True)(pname=(ns,"pvlanConfigSpec"), aname="_pvlanConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMtu"), aname="_maxMtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkDiscoveryProtocolConfig",lazy=True)(pname=(ns,"linkDiscoveryProtocolConfig"), aname="_linkDiscoveryProtocolConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVSConfigSpec_Def not in ns0.VMwareDVSConfigSpec_Def.__bases__: - bases = list(ns0.VMwareDVSConfigSpec_Def.__bases__) - bases.insert(0, ns0.DVSConfigSpec_Def) - ns0.VMwareDVSConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DVSConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMwareUplinkPortOrderPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMwareUplinkPortOrderPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMwareUplinkPortOrderPolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"activeUplinkPort"), aname="_activeUplinkPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"standbyUplinkPort"), aname="_standbyUplinkPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.VMwareUplinkPortOrderPolicy_Def.__bases__: - bases = list(ns0.VMwareUplinkPortOrderPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.VMwareUplinkPortOrderPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSFailureCriteria_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSFailureCriteria") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSFailureCriteria_Def.schema - TClist = [GTD("urn:vim25","StringPolicy",lazy=True)(pname=(ns,"checkSpeed"), aname="_checkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntPolicy",lazy=True)(pname=(ns,"speed"), aname="_speed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"checkDuplex"), aname="_checkDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"fullDuplex"), aname="_fullDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"checkErrorPercent"), aname="_checkErrorPercent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntPolicy",lazy=True)(pname=(ns,"percentage"), aname="_percentage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"checkBeacon"), aname="_checkBeacon", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.DVSFailureCriteria_Def.__bases__: - bases = list(ns0.DVSFailureCriteria_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.DVSFailureCriteria_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmwareUplinkPortTeamingPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmwareUplinkPortTeamingPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmwareUplinkPortTeamingPolicy_Def.schema - TClist = [GTD("urn:vim25","StringPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"reversePolicy"), aname="_reversePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"notifySwitches"), aname="_notifySwitches", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"rollingOrder"), aname="_rollingOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSFailureCriteria",lazy=True)(pname=(ns,"failureCriteria"), aname="_failureCriteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VMwareUplinkPortOrderPolicy",lazy=True)(pname=(ns,"uplinkPortOrder"), aname="_uplinkPortOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.VmwareUplinkPortTeamingPolicy_Def.__bases__: - bases = list(ns0.VmwareUplinkPortTeamingPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.VmwareUplinkPortTeamingPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmwareDistributedVirtualSwitchVlanSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmwareDistributedVirtualSwitchVlanSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__bases__: - bases = list(ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmwareDistributedVirtualSwitchPvlanSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmwareDistributedVirtualSwitchPvlanSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"pvlanId"), aname="_pvlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmwareDistributedVirtualSwitchVlanSpec_Def not in ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.__bases__: - bases = list(ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.__bases__) - bases.insert(0, ns0.VmwareDistributedVirtualSwitchVlanSpec_Def) - ns0.VmwareDistributedVirtualSwitchPvlanSpec_Def.__bases__ = tuple(bases) - - ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmwareDistributedVirtualSwitchVlanIdSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmwareDistributedVirtualSwitchVlanIdSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmwareDistributedVirtualSwitchVlanSpec_Def not in ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.__bases__: - bases = list(ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.__bases__) - bases.insert(0, ns0.VmwareDistributedVirtualSwitchVlanSpec_Def) - ns0.VmwareDistributedVirtualSwitchVlanIdSpec_Def.__bases__ = tuple(bases) - - ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmwareDistributedVirtualSwitchTrunkVlanSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmwareDistributedVirtualSwitchTrunkVlanSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.schema - TClist = [GTD("urn:vim25","NumericRange",lazy=True)(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmwareDistributedVirtualSwitchVlanSpec_Def not in ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.__bases__: - bases = list(ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.__bases__) - bases.insert(0, ns0.VmwareDistributedVirtualSwitchVlanSpec_Def) - ns0.VmwareDistributedVirtualSwitchTrunkVlanSpec_Def.__bases__ = tuple(bases) - - ns0.VmwareDistributedVirtualSwitchVlanSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVSSecurityPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVSSecurityPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVSSecurityPolicy_Def.schema - TClist = [GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"allowPromiscuous"), aname="_allowPromiscuous", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"macChanges"), aname="_macChanges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"forgedTransmits"), aname="_forgedTransmits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InheritablePolicy_Def not in ns0.DVSSecurityPolicy_Def.__bases__: - bases = list(ns0.DVSSecurityPolicy_Def.__bases__) - bases.insert(0, ns0.InheritablePolicy_Def) - ns0.DVSSecurityPolicy_Def.__bases__ = tuple(bases) - - ns0.InheritablePolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMwareDVSPortSetting_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMwareDVSPortSetting") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMwareDVSPortSetting_Def.schema - TClist = [GTD("urn:vim25","VmwareDistributedVirtualSwitchVlanSpec",lazy=True)(pname=(ns,"vlan"), aname="_vlan", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntPolicy",lazy=True)(pname=(ns,"qosTag"), aname="_qosTag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmwareUplinkPortTeamingPolicy",lazy=True)(pname=(ns,"uplinkTeamingPolicy"), aname="_uplinkTeamingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DVSSecurityPolicy",lazy=True)(pname=(ns,"securityPolicy"), aname="_securityPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolPolicy",lazy=True)(pname=(ns,"txUplink"), aname="_txUplink", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVPortSetting_Def not in ns0.VMwareDVSPortSetting_Def.__bases__: - bases = list(ns0.VMwareDVSPortSetting_Def.__bases__) - bases.insert(0, ns0.DVPortSetting_Def) - ns0.VMwareDVSPortSetting_Def.__bases__ = tuple(bases) - - ns0.DVPortSetting_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMwareDVSPortgroupPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMwareDVSPortgroupPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMwareDVSPortgroupPolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"vlanOverrideAllowed"), aname="_vlanOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uplinkTeamingOverrideAllowed"), aname="_uplinkTeamingOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"securityPolicyOverrideAllowed"), aname="_securityPolicyOverrideAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVPortgroupPolicy_Def not in ns0.VMwareDVSPortgroupPolicy_Def.__bases__: - bases = list(ns0.VMwareDVSPortgroupPolicy_Def.__bases__) - bases.insert(0, ns0.DVPortgroupPolicy_Def) - ns0.VMwareDVSPortgroupPolicy_Def.__bases__ = tuple(bases) - - ns0.DVPortgroupPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmwareDistributedVirtualSwitchPvlanPortType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VmwareDistributedVirtualSwitchPvlanPortType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VMwareDVSPvlanConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMwareDVSPvlanConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMwareDVSPvlanConfigSpec_Def.schema - TClist = [GTD("urn:vim25","VMwareDVSPvlanMapEntry",lazy=True)(pname=(ns,"pvlanEntry"), aname="_pvlanEntry", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VMwareDVSPvlanConfigSpec_Def.__bases__: - bases = list(ns0.VMwareDVSPvlanConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VMwareDVSPvlanConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVMwareDVSPvlanConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVMwareDVSPvlanConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVMwareDVSPvlanConfigSpec_Def.schema - TClist = [GTD("urn:vim25","VMwareDVSPvlanConfigSpec",lazy=True)(pname=(ns,"VMwareDVSPvlanConfigSpec"), aname="_VMwareDVSPvlanConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VMwareDVSPvlanConfigSpec = [] - return - Holder.__name__ = "ArrayOfVMwareDVSPvlanConfigSpec_Holder" - self.pyclass = Holder - - class VMwareDVSPvlanMapEntry_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMwareDVSPvlanMapEntry") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMwareDVSPvlanMapEntry_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"primaryVlanId"), aname="_primaryVlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"secondaryVlanId"), aname="_secondaryVlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pvlanType"), aname="_pvlanType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VMwareDVSPvlanMapEntry_Def.__bases__: - bases = list(ns0.VMwareDVSPvlanMapEntry_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VMwareDVSPvlanMapEntry_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVMwareDVSPvlanMapEntry_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVMwareDVSPvlanMapEntry") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVMwareDVSPvlanMapEntry_Def.schema - TClist = [GTD("urn:vim25","VMwareDVSPvlanMapEntry",lazy=True)(pname=(ns,"VMwareDVSPvlanMapEntry"), aname="_VMwareDVSPvlanMapEntry", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VMwareDVSPvlanMapEntry = [] - return - Holder.__name__ = "ArrayOfVMwareDVSPvlanMapEntry_Holder" - self.pyclass = Holder - - class EventEventSeverity_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EventEventSeverity") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class Event_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Event") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Event_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"chainId"), aname="_chainId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"createdTime"), aname="_createdTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatacenterEventArgument",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComputeResourceEventArgument",lazy=True)(pname=(ns,"computeResource"), aname="_computeResource", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"ds"), aname="_ds", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkEventArgument",lazy=True)(pname=(ns,"net"), aname="_net", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsEventArgument",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullFormattedMessage"), aname="_fullFormattedMessage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeTag"), aname="_changeTag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.Event_Def.__bases__: - bases = list(ns0.Event_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.Event_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfEvent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfEvent") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfEvent_Def.schema - TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"Event"), aname="_Event", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._Event = [] - return - Holder.__name__ = "ArrayOfEvent_Holder" - self.pyclass = Holder - - class EventEx_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventEx") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventEx_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"severity"), aname="_severity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"arguments"), aname="_arguments", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectId"), aname="_objectId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectType"), aname="_objectType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.EventEx_Def.__bases__: - bases = list(ns0.EventEx_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.EventEx_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.GeneralEvent_Def.__bases__: - bases = list(ns0.GeneralEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.GeneralEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralHostInfoEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralHostInfoEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralHostInfoEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.GeneralHostInfoEvent_Def.__bases__: - bases = list(ns0.GeneralHostInfoEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.GeneralHostInfoEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralHostWarningEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralHostWarningEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralHostWarningEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.GeneralHostWarningEvent_Def.__bases__: - bases = list(ns0.GeneralHostWarningEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.GeneralHostWarningEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralHostErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralHostErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralHostErrorEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.GeneralHostErrorEvent_Def.__bases__: - bases = list(ns0.GeneralHostErrorEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.GeneralHostErrorEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralVmInfoEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralVmInfoEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralVmInfoEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.GeneralVmInfoEvent_Def.__bases__: - bases = list(ns0.GeneralVmInfoEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.GeneralVmInfoEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralVmWarningEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralVmWarningEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralVmWarningEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.GeneralVmWarningEvent_Def.__bases__: - bases = list(ns0.GeneralVmWarningEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.GeneralVmWarningEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralVmErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralVmErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralVmErrorEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.GeneralVmErrorEvent_Def.__bases__: - bases = list(ns0.GeneralVmErrorEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.GeneralVmErrorEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GeneralUserEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GeneralUserEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GeneralUserEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.GeneralUserEvent_Def.__bases__: - bases = list(ns0.GeneralUserEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.GeneralUserEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExtendedEventPair_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtendedEventPair") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtendedEventPair_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ExtendedEventPair_Def.__bases__: - bases = list(ns0.ExtendedEventPair_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ExtendedEventPair_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfExtendedEventPair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfExtendedEventPair") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfExtendedEventPair_Def.schema - TClist = [GTD("urn:vim25","ExtendedEventPair",lazy=True)(pname=(ns,"ExtendedEventPair"), aname="_ExtendedEventPair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ExtendedEventPair = [] - return - Holder.__name__ = "ArrayOfExtendedEventPair_Holder" - self.pyclass = Holder - - class ExtendedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtendedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtendedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"managedObject"), aname="_managedObject", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtendedEventPair",lazy=True)(pname=(ns,"data"), aname="_data", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.GeneralEvent_Def not in ns0.ExtendedEvent_Def.__bases__: - bases = list(ns0.ExtendedEvent_Def.__bases__) - bases.insert(0, ns0.GeneralEvent_Def) - ns0.ExtendedEvent_Def.__bases__ = tuple(bases) - - ns0.GeneralEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HealthStatusChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HealthStatusChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HealthStatusChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"componentId"), aname="_componentId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"oldStatus"), aname="_oldStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newStatus"), aname="_newStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"componentName"), aname="_componentName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.HealthStatusChangedEvent_Def.__bases__: - bases = list(ns0.HealthStatusChangedEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.HealthStatusChangedEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInventoryUnreadableEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInventoryUnreadableEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInventoryUnreadableEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.HostInventoryUnreadableEvent_Def.__bases__: - bases = list(ns0.HostInventoryUnreadableEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.HostInventoryUnreadableEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatacenterEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatacenterEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatacenterEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.DatacenterEvent_Def.__bases__: - bases = list(ns0.DatacenterEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.DatacenterEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatacenterCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatacenterCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatacenterCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatacenterEvent_Def not in ns0.DatacenterCreatedEvent_Def.__bases__: - bases = list(ns0.DatacenterCreatedEvent_Def.__bases__) - bases.insert(0, ns0.DatacenterEvent_Def) - ns0.DatacenterCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.DatacenterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatacenterRenamedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatacenterRenamedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatacenterRenamedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatacenterEvent_Def not in ns0.DatacenterRenamedEvent_Def.__bases__: - bases = list(ns0.DatacenterRenamedEvent_Def.__bases__) - bases.insert(0, ns0.DatacenterEvent_Def) - ns0.DatacenterRenamedEvent_Def.__bases__ = tuple(bases) - - ns0.DatacenterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SessionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SessionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SessionEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.SessionEvent_Def.__bases__: - bases = list(ns0.SessionEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.SessionEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ServerStartedSessionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ServerStartedSessionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ServerStartedSessionEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.ServerStartedSessionEvent_Def.__bases__: - bases = list(ns0.ServerStartedSessionEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.ServerStartedSessionEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserLoginSessionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserLoginSessionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserLoginSessionEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locale"), aname="_locale", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.UserLoginSessionEvent_Def.__bases__: - bases = list(ns0.UserLoginSessionEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.UserLoginSessionEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserLogoutSessionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserLogoutSessionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserLogoutSessionEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.UserLogoutSessionEvent_Def.__bases__: - bases = list(ns0.UserLogoutSessionEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.UserLogoutSessionEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class BadUsernameSessionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "BadUsernameSessionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.BadUsernameSessionEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.BadUsernameSessionEvent_Def.__bases__: - bases = list(ns0.BadUsernameSessionEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.BadUsernameSessionEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlreadyAuthenticatedSessionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlreadyAuthenticatedSessionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlreadyAuthenticatedSessionEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.AlreadyAuthenticatedSessionEvent_Def.__bases__: - bases = list(ns0.AlreadyAuthenticatedSessionEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.AlreadyAuthenticatedSessionEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoAccessUserEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoAccessUserEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoAccessUserEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.NoAccessUserEvent_Def.__bases__: - bases = list(ns0.NoAccessUserEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.NoAccessUserEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SessionTerminatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SessionTerminatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SessionTerminatedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"sessionId"), aname="_sessionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"terminatedUsername"), aname="_terminatedUsername", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.SessionTerminatedEvent_Def.__bases__: - bases = list(ns0.SessionTerminatedEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.SessionTerminatedEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GlobalMessageChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GlobalMessageChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GlobalMessageChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SessionEvent_Def not in ns0.GlobalMessageChangedEvent_Def.__bases__: - bases = list(ns0.GlobalMessageChangedEvent_Def.__bases__) - bases.insert(0, ns0.SessionEvent_Def) - ns0.GlobalMessageChangedEvent_Def.__bases__ = tuple(bases) - - ns0.SessionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpgradeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UpgradeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UpgradeEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.UpgradeEvent_Def.__bases__: - bases = list(ns0.UpgradeEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.UpgradeEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InfoUpgradeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InfoUpgradeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InfoUpgradeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.UpgradeEvent_Def not in ns0.InfoUpgradeEvent_Def.__bases__: - bases = list(ns0.InfoUpgradeEvent_Def.__bases__) - bases.insert(0, ns0.UpgradeEvent_Def) - ns0.InfoUpgradeEvent_Def.__bases__ = tuple(bases) - - ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class WarningUpgradeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "WarningUpgradeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.WarningUpgradeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.UpgradeEvent_Def not in ns0.WarningUpgradeEvent_Def.__bases__: - bases = list(ns0.WarningUpgradeEvent_Def.__bases__) - bases.insert(0, ns0.UpgradeEvent_Def) - ns0.WarningUpgradeEvent_Def.__bases__ = tuple(bases) - - ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ErrorUpgradeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ErrorUpgradeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ErrorUpgradeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.UpgradeEvent_Def not in ns0.ErrorUpgradeEvent_Def.__bases__: - bases = list(ns0.ErrorUpgradeEvent_Def.__bases__) - bases.insert(0, ns0.UpgradeEvent_Def) - ns0.ErrorUpgradeEvent_Def.__bases__ = tuple(bases) - - ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserUpgradeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserUpgradeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserUpgradeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.UpgradeEvent_Def not in ns0.UserUpgradeEvent_Def.__bases__: - bases = list(ns0.UserUpgradeEvent_Def.__bases__) - bases.insert(0, ns0.UpgradeEvent_Def) - ns0.UserUpgradeEvent_Def.__bases__ = tuple(bases) - - ns0.UpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.HostEvent_Def.__bases__: - bases = list(ns0.HostEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.HostEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDasEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDasEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDasEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDasEvent_Def.__bases__: - bases = list(ns0.HostDasEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDasEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConnectedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostConnectedEvent_Def.__bases__: - bases = list(ns0.HostConnectedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostConnectedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDisconnectedEventReasonCode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostDisconnectedEventReasonCode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostDisconnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDisconnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDisconnectedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDisconnectedEvent_Def.__bases__: - bases = list(ns0.HostDisconnectedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDisconnectedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostSyncFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSyncFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSyncFailedEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostSyncFailedEvent_Def.__bases__: - bases = list(ns0.HostSyncFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostSyncFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConnectionLostEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConnectionLostEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConnectionLostEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostConnectionLostEvent_Def.__bases__: - bases = list(ns0.HostConnectionLostEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostConnectionLostEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostReconnectionFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostReconnectionFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostReconnectionFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostReconnectionFailedEvent_Def.__bases__: - bases = list(ns0.HostReconnectionFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostReconnectionFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedNoConnectionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedNoConnectionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedNoConnectionEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedNoConnectionEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedNoConnectionEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedNoConnectionEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedBadUsernameEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedBadUsernameEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedBadUsernameEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedBadUsernameEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedBadUsernameEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedBadUsernameEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedBadVersionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedBadVersionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedBadVersionEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedBadVersionEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedBadVersionEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedBadVersionEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedAlreadyManagedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedAlreadyManagedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedAlreadyManagedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"serverName"), aname="_serverName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedAlreadyManagedEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedAlreadyManagedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedAlreadyManagedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedNoLicenseEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedNoLicenseEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedNoLicenseEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedNoLicenseEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedNoLicenseEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedNoLicenseEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedNetworkErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedNetworkErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedNetworkErrorEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedNetworkErrorEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedNetworkErrorEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedNetworkErrorEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostRemovedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostRemovedEvent_Def.__bases__: - bases = list(ns0.HostRemovedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedCcagentUpgradeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedCcagentUpgradeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedCcagentUpgradeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedCcagentUpgradeEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedCcagentUpgradeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedCcagentUpgradeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedBadCcagentEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedBadCcagentEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedBadCcagentEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedBadCcagentEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedBadCcagentEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedBadCcagentEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedAccountFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedAccountFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedAccountFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedAccountFailedEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedAccountFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedAccountFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedNoAccessEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedNoAccessEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedNoAccessEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedNoAccessEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedNoAccessEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedNoAccessEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostShutdownEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostShutdownEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostShutdownEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostShutdownEvent_Def.__bases__: - bases = list(ns0.HostShutdownEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostShutdownEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedNotFoundEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedNotFoundEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedNotFoundEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedNotFoundEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedNotFoundEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedNotFoundEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCnxFailedTimeoutEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCnxFailedTimeoutEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCnxFailedTimeoutEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCnxFailedTimeoutEvent_Def.__bases__: - bases = list(ns0.HostCnxFailedTimeoutEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCnxFailedTimeoutEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostUpgradeFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUpgradeFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUpgradeFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostUpgradeFailedEvent_Def.__bases__: - bases = list(ns0.HostUpgradeFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostUpgradeFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EnteringMaintenanceModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EnteringMaintenanceModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EnteringMaintenanceModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.EnteringMaintenanceModeEvent_Def.__bases__: - bases = list(ns0.EnteringMaintenanceModeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.EnteringMaintenanceModeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EnteredMaintenanceModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EnteredMaintenanceModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EnteredMaintenanceModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.EnteredMaintenanceModeEvent_Def.__bases__: - bases = list(ns0.EnteredMaintenanceModeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.EnteredMaintenanceModeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExitMaintenanceModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExitMaintenanceModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExitMaintenanceModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.ExitMaintenanceModeEvent_Def.__bases__: - bases = list(ns0.ExitMaintenanceModeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.ExitMaintenanceModeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CanceledHostOperationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CanceledHostOperationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CanceledHostOperationEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.CanceledHostOperationEvent_Def.__bases__: - bases = list(ns0.CanceledHostOperationEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.CanceledHostOperationEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TimedOutHostOperationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TimedOutHostOperationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TimedOutHostOperationEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.TimedOutHostOperationEvent_Def.__bases__: - bases = list(ns0.TimedOutHostOperationEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.TimedOutHostOperationEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDasEnabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDasEnabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDasEnabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDasEnabledEvent_Def.__bases__: - bases = list(ns0.HostDasEnabledEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDasEnabledEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDasDisabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDasDisabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDasDisabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDasDisabledEvent_Def.__bases__: - bases = list(ns0.HostDasDisabledEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDasDisabledEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDasEnablingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDasEnablingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDasEnablingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDasEnablingEvent_Def.__bases__: - bases = list(ns0.HostDasEnablingEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDasEnablingEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDasDisablingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDasDisablingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDasDisablingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDasDisablingEvent_Def.__bases__: - bases = list(ns0.HostDasDisablingEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDasDisablingEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDasErrorEventHostDasErrorReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostDasErrorEventHostDasErrorReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostDasErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDasErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDasErrorEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDasErrorEvent_Def.__bases__: - bases = list(ns0.HostDasErrorEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDasErrorEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDasOkEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDasOkEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDasOkEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostDasOkEvent_Def.__bases__: - bases = list(ns0.HostDasOkEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostDasOkEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VcAgentUpgradedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VcAgentUpgradedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VcAgentUpgradedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VcAgentUpgradedEvent_Def.__bases__: - bases = list(ns0.VcAgentUpgradedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VcAgentUpgradedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VcAgentUninstalledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VcAgentUninstalledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VcAgentUninstalledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VcAgentUninstalledEvent_Def.__bases__: - bases = list(ns0.VcAgentUninstalledEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VcAgentUninstalledEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VcAgentUpgradeFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VcAgentUpgradeFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VcAgentUpgradeFailedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VcAgentUpgradeFailedEvent_Def.__bases__: - bases = list(ns0.VcAgentUpgradeFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VcAgentUpgradeFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VcAgentUninstallFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VcAgentUninstallFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VcAgentUninstallFailedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VcAgentUninstallFailedEvent_Def.__bases__: - bases = list(ns0.VcAgentUninstallFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VcAgentUninstallFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostAddedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostAddedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostAddedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostAddedEvent_Def.__bases__: - bases = list(ns0.HostAddedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostAddedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostAddFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostAddFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostAddFailedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostAddFailedEvent_Def.__bases__: - bases = list(ns0.HostAddFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostAddFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldIP"), aname="_oldIP", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newIP"), aname="_newIP", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostIpChangedEvent_Def.__bases__: - bases = list(ns0.HostIpChangedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostIpChangedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EnteringStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EnteringStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EnteringStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.EnteringStandbyModeEvent_Def.__bases__: - bases = list(ns0.EnteringStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.EnteringStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsEnteringStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsEnteringStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsEnteringStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EnteringStandbyModeEvent_Def not in ns0.DrsEnteringStandbyModeEvent_Def.__bases__: - bases = list(ns0.DrsEnteringStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.EnteringStandbyModeEvent_Def) - ns0.DrsEnteringStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.EnteringStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EnteredStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EnteredStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EnteredStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.EnteredStandbyModeEvent_Def.__bases__: - bases = list(ns0.EnteredStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.EnteredStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsEnteredStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsEnteredStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsEnteredStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EnteredStandbyModeEvent_Def not in ns0.DrsEnteredStandbyModeEvent_Def.__bases__: - bases = list(ns0.DrsEnteredStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.EnteredStandbyModeEvent_Def) - ns0.DrsEnteredStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.EnteredStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExitingStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExitingStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExitingStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.ExitingStandbyModeEvent_Def.__bases__: - bases = list(ns0.ExitingStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.ExitingStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsExitingStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsExitingStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsExitingStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ExitingStandbyModeEvent_Def not in ns0.DrsExitingStandbyModeEvent_Def.__bases__: - bases = list(ns0.DrsExitingStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.ExitingStandbyModeEvent_Def) - ns0.DrsExitingStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.ExitingStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExitedStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExitedStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExitedStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.ExitedStandbyModeEvent_Def.__bases__: - bases = list(ns0.ExitedStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.ExitedStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsExitedStandbyModeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsExitedStandbyModeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsExitedStandbyModeEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ExitedStandbyModeEvent_Def not in ns0.DrsExitedStandbyModeEvent_Def.__bases__: - bases = list(ns0.DrsExitedStandbyModeEvent_Def.__bases__) - bases.insert(0, ns0.ExitedStandbyModeEvent_Def) - ns0.DrsExitedStandbyModeEvent_Def.__bases__ = tuple(bases) - - ns0.ExitedStandbyModeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExitStandbyModeFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExitStandbyModeFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExitStandbyModeFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.ExitStandbyModeFailedEvent_Def.__bases__: - bases = list(ns0.ExitStandbyModeFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.ExitStandbyModeFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsExitStandbyModeFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsExitStandbyModeFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsExitStandbyModeFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ExitStandbyModeFailedEvent_Def not in ns0.DrsExitStandbyModeFailedEvent_Def.__bases__: - bases = list(ns0.DrsExitStandbyModeFailedEvent_Def.__bases__) - bases.insert(0, ns0.ExitStandbyModeFailedEvent_Def) - ns0.DrsExitStandbyModeFailedEvent_Def.__bases__ = tuple(bases) - - ns0.ExitStandbyModeFailedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdatedAgentBeingRestartedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UpdatedAgentBeingRestartedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UpdatedAgentBeingRestartedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.UpdatedAgentBeingRestartedEvent_Def.__bases__: - bases = list(ns0.UpdatedAgentBeingRestartedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.UpdatedAgentBeingRestartedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AccountCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AccountCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AccountCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.AccountCreatedEvent_Def.__bases__: - bases = list(ns0.AccountCreatedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.AccountCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AccountRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AccountRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AccountRemovedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"account"), aname="_account", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.AccountRemovedEvent_Def.__bases__: - bases = list(ns0.AccountRemovedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.AccountRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserPasswordChanged_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserPasswordChanged") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserPasswordChanged_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userLogin"), aname="_userLogin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.UserPasswordChanged_Def.__bases__: - bases = list(ns0.UserPasswordChanged_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.UserPasswordChanged_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AccountUpdatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AccountUpdatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AccountUpdatedEvent_Def.schema - TClist = [GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.AccountUpdatedEvent_Def.__bases__: - bases = list(ns0.AccountUpdatedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.AccountUpdatedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserAssignedToGroup_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserAssignedToGroup") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserAssignedToGroup_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userLogin"), aname="_userLogin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.UserAssignedToGroup_Def.__bases__: - bases = list(ns0.UserAssignedToGroup_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.UserAssignedToGroup_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserUnassignedFromGroup_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserUnassignedFromGroup") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserUnassignedFromGroup_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userLogin"), aname="_userLogin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.UserUnassignedFromGroup_Def.__bases__: - bases = list(ns0.UserUnassignedFromGroup_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.UserUnassignedFromGroup_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastorePrincipalConfigured_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastorePrincipalConfigured") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastorePrincipalConfigured_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"datastorePrincipal"), aname="_datastorePrincipal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.DatastorePrincipalConfigured_Def.__bases__: - bases = list(ns0.DatastorePrincipalConfigured_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.DatastorePrincipalConfigured_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMFSDatastoreCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMFSDatastoreCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMFSDatastoreCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VMFSDatastoreCreatedEvent_Def.__bases__: - bases = list(ns0.VMFSDatastoreCreatedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VMFSDatastoreCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NASDatastoreCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NASDatastoreCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NASDatastoreCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.NASDatastoreCreatedEvent_Def.__bases__: - bases = list(ns0.NASDatastoreCreatedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.NASDatastoreCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LocalDatastoreCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LocalDatastoreCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LocalDatastoreCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.LocalDatastoreCreatedEvent_Def.__bases__: - bases = list(ns0.LocalDatastoreCreatedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.LocalDatastoreCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMFSDatastoreExtendedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMFSDatastoreExtendedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMFSDatastoreExtendedEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VMFSDatastoreExtendedEvent_Def.__bases__: - bases = list(ns0.VMFSDatastoreExtendedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VMFSDatastoreExtendedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMFSDatastoreExpandedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMFSDatastoreExpandedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMFSDatastoreExpandedEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VMFSDatastoreExpandedEvent_Def.__bases__: - bases = list(ns0.VMFSDatastoreExpandedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VMFSDatastoreExpandedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreRemovedOnHostEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreRemovedOnHostEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreRemovedOnHostEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.DatastoreRemovedOnHostEvent_Def.__bases__: - bases = list(ns0.DatastoreRemovedOnHostEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.DatastoreRemovedOnHostEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreRenamedOnHostEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreRenamedOnHostEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreRenamedOnHostEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.DatastoreRenamedOnHostEvent_Def.__bases__: - bases = list(ns0.DatastoreRenamedOnHostEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.DatastoreRenamedOnHostEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DuplicateIpDetectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DuplicateIpDetectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DuplicateIpDetectedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"duplicateIP"), aname="_duplicateIP", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.DuplicateIpDetectedEvent_Def.__bases__: - bases = list(ns0.DuplicateIpDetectedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.DuplicateIpDetectedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreDiscoveredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreDiscoveredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreDiscoveredEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.DatastoreDiscoveredEvent_Def.__bases__: - bases = list(ns0.DatastoreDiscoveredEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.DatastoreDiscoveredEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsResourceConfigureFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsResourceConfigureFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsResourceConfigureFailedEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.DrsResourceConfigureFailedEvent_Def.__bases__: - bases = list(ns0.DrsResourceConfigureFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.DrsResourceConfigureFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsResourceConfigureSyncedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsResourceConfigureSyncedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsResourceConfigureSyncedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.DrsResourceConfigureSyncedEvent_Def.__bases__: - bases = list(ns0.DrsResourceConfigureSyncedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.DrsResourceConfigureSyncedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostGetShortNameFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostGetShortNameFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostGetShortNameFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostGetShortNameFailedEvent_Def.__bases__: - bases = list(ns0.HostGetShortNameFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostGetShortNameFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostShortNameToIpFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostShortNameToIpFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostShortNameToIpFailedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"shortName"), aname="_shortName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostShortNameToIpFailedEvent_Def.__bases__: - bases = list(ns0.HostShortNameToIpFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostShortNameToIpFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpToShortNameFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpToShortNameFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpToShortNameFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostIpToShortNameFailedEvent_Def.__bases__: - bases = list(ns0.HostIpToShortNameFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostIpToShortNameFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostPrimaryAgentNotShortNameEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPrimaryAgentNotShortNameEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPrimaryAgentNotShortNameEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"primaryAgent"), aname="_primaryAgent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostPrimaryAgentNotShortNameEvent_Def.__bases__: - bases = list(ns0.HostPrimaryAgentNotShortNameEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostPrimaryAgentNotShortNameEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNotInClusterEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNotInClusterEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNotInClusterEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostNotInClusterEvent_Def.__bases__: - bases = list(ns0.HostNotInClusterEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostNotInClusterEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIsolationIpPingFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIsolationIpPingFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIsolationIpPingFailedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"isolationIp"), aname="_isolationIp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostIsolationIpPingFailedEvent_Def.__bases__: - bases = list(ns0.HostIsolationIpPingFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostIsolationIpPingFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpInconsistentEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpInconsistentEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpInconsistentEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress2"), aname="_ipAddress2", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostIpInconsistentEvent_Def.__bases__: - bases = list(ns0.HostIpInconsistentEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostIpInconsistentEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostUserWorldSwapNotEnabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUserWorldSwapNotEnabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUserWorldSwapNotEnabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostUserWorldSwapNotEnabledEvent_Def.__bases__: - bases = list(ns0.HostUserWorldSwapNotEnabledEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostUserWorldSwapNotEnabledEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNonCompliantEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNonCompliantEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNonCompliantEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostNonCompliantEvent_Def.__bases__: - bases = list(ns0.HostNonCompliantEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostNonCompliantEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCompliantEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCompliantEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCompliantEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostCompliantEvent_Def.__bases__: - bases = list(ns0.HostCompliantEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostCompliantEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostComplianceCheckedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostComplianceCheckedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostComplianceCheckedEvent_Def.schema - TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostComplianceCheckedEvent_Def.__bases__: - bases = list(ns0.HostComplianceCheckedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostComplianceCheckedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterComplianceCheckedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterComplianceCheckedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterComplianceCheckedEvent_Def.schema - TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.ClusterComplianceCheckedEvent_Def.__bases__: - bases = list(ns0.ClusterComplianceCheckedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.ClusterComplianceCheckedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileEvent_Def.schema - TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.ProfileEvent_Def.__bases__: - bases = list(ns0.ProfileEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.ProfileEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileCreatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileEvent_Def not in ns0.ProfileCreatedEvent_Def.__bases__: - bases = list(ns0.ProfileCreatedEvent_Def.__bases__) - bases.insert(0, ns0.ProfileEvent_Def) - ns0.ProfileCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileRemovedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileEvent_Def not in ns0.ProfileRemovedEvent_Def.__bases__: - bases = list(ns0.ProfileRemovedEvent_Def.__bases__) - bases.insert(0, ns0.ProfileEvent_Def) - ns0.ProfileRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileAssociatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileAssociatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileAssociatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileEvent_Def not in ns0.ProfileAssociatedEvent_Def.__bases__: - bases = list(ns0.ProfileAssociatedEvent_Def.__bases__) - bases.insert(0, ns0.ProfileEvent_Def) - ns0.ProfileAssociatedEvent_Def.__bases__ = tuple(bases) - - ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileDissociatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileDissociatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileDissociatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileEvent_Def not in ns0.ProfileDissociatedEvent_Def.__bases__: - bases = list(ns0.ProfileDissociatedEvent_Def.__bases__) - bases.insert(0, ns0.ProfileEvent_Def) - ns0.ProfileDissociatedEvent_Def.__bases__ = tuple(bases) - - ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigAppliedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigAppliedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigAppliedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostConfigAppliedEvent_Def.__bases__: - bases = list(ns0.HostConfigAppliedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostConfigAppliedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileReferenceHostChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileReferenceHostChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileReferenceHostChangedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"referenceHost"), aname="_referenceHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileEvent_Def not in ns0.ProfileReferenceHostChangedEvent_Def.__bases__: - bases = list(ns0.ProfileReferenceHostChangedEvent_Def.__bases__) - bases.insert(0, ns0.ProfileEvent_Def) - ns0.ProfileReferenceHostChangedEvent_Def.__bases__ = tuple(bases) - - ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileChangedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileEvent_Def not in ns0.ProfileChangedEvent_Def.__bases__: - bases = list(ns0.ProfileChangedEvent_Def.__bases__) - bases.insert(0, ns0.ProfileEvent_Def) - ns0.ProfileChangedEvent_Def.__bases__ = tuple(bases) - - ns0.ProfileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProfileAppliedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProfileAppliedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProfileAppliedEvent_Def.schema - TClist = [GTD("urn:vim25","ProfileEventArgument",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostProfileAppliedEvent_Def.__bases__: - bases = list(ns0.HostProfileAppliedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostProfileAppliedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostShortNameInconsistentEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostShortNameInconsistentEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostShortNameInconsistentEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"shortName"), aname="_shortName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"shortName2"), aname="_shortName2", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostShortNameInconsistentEvent_Def.__bases__: - bases = list(ns0.HostShortNameInconsistentEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostShortNameInconsistentEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNoRedundantManagementNetworkEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNoRedundantManagementNetworkEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNoRedundantManagementNetworkEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostNoRedundantManagementNetworkEvent_Def.__bases__: - bases = list(ns0.HostNoRedundantManagementNetworkEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostNoRedundantManagementNetworkEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNoAvailableNetworksEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNoAvailableNetworksEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNoAvailableNetworksEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ips"), aname="_ips", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostNoAvailableNetworksEvent_Def.__bases__: - bases = list(ns0.HostNoAvailableNetworksEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostNoAvailableNetworksEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostExtraNetworksEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostExtraNetworksEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostExtraNetworksEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ips"), aname="_ips", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostExtraNetworksEvent_Def.__bases__: - bases = list(ns0.HostExtraNetworksEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostExtraNetworksEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNoHAEnabledPortGroupsEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNoHAEnabledPortGroupsEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNoHAEnabledPortGroupsEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostNoHAEnabledPortGroupsEvent_Def.__bases__: - bases = list(ns0.HostNoHAEnabledPortGroupsEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostNoHAEnabledPortGroupsEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostMissingNetworksEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMissingNetworksEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMissingNetworksEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ips"), aname="_ips", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDasEvent_Def not in ns0.HostMissingNetworksEvent_Def.__bases__: - bases = list(ns0.HostMissingNetworksEvent_Def.__bases__) - bases.insert(0, ns0.HostDasEvent_Def) - ns0.HostMissingNetworksEvent_Def.__bases__ = tuple(bases) - - ns0.HostDasEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VnicPortArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VnicPortArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VnicPortArgument_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VnicPortArgument_Def.__bases__: - bases = list(ns0.VnicPortArgument_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VnicPortArgument_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVnicPortArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVnicPortArgument") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVnicPortArgument_Def.schema - TClist = [GTD("urn:vim25","VnicPortArgument",lazy=True)(pname=(ns,"VnicPortArgument"), aname="_VnicPortArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VnicPortArgument = [] - return - Holder.__name__ = "ArrayOfVnicPortArgument_Holder" - self.pyclass = Holder - - class HostVnicConnectedToCustomizedDVPortEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVnicConnectedToCustomizedDVPortEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.schema - TClist = [GTD("urn:vim25","VnicPortArgument",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.__bases__: - bases = list(ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostVnicConnectedToCustomizedDVPortEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GhostDvsProxySwitchDetectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GhostDvsProxySwitchDetectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GhostDvsProxySwitchDetectedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.GhostDvsProxySwitchDetectedEvent_Def.__bases__: - bases = list(ns0.GhostDvsProxySwitchDetectedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.GhostDvsProxySwitchDetectedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GhostDvsProxySwitchRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GhostDvsProxySwitchRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GhostDvsProxySwitchRemovedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"switchUuid"), aname="_switchUuid", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.GhostDvsProxySwitchRemovedEvent_Def.__bases__: - bases = list(ns0.GhostDvsProxySwitchRemovedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.GhostDvsProxySwitchRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmEvent_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.VmEvent_Def.__bases__: - bases = list(ns0.VmEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.VmEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmPoweredOffEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmPoweredOffEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmPoweredOffEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmPoweredOffEvent_Def.__bases__: - bases = list(ns0.VmPoweredOffEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmPoweredOffEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmPoweredOnEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmPoweredOnEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmPoweredOnEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmPoweredOnEvent_Def.__bases__: - bases = list(ns0.VmPoweredOnEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmPoweredOnEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSuspendedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSuspendedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSuspendedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmSuspendedEvent_Def.__bases__: - bases = list(ns0.VmSuspendedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmSuspendedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmStartingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmStartingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmStartingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmStartingEvent_Def.__bases__: - bases = list(ns0.VmStartingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmStartingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmStoppingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmStoppingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmStoppingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmStoppingEvent_Def.__bases__: - bases = list(ns0.VmStoppingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmStoppingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSuspendingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSuspendingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSuspendingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmSuspendingEvent_Def.__bases__: - bases = list(ns0.VmSuspendingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmSuspendingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmResumingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmResumingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmResumingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmResumingEvent_Def.__bases__: - bases = list(ns0.VmResumingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmResumingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDisconnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDisconnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDisconnectedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDisconnectedEvent_Def.__bases__: - bases = list(ns0.VmDisconnectedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDisconnectedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRemoteConsoleConnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRemoteConsoleConnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRemoteConsoleConnectedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRemoteConsoleConnectedEvent_Def.__bases__: - bases = list(ns0.VmRemoteConsoleConnectedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRemoteConsoleConnectedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRemoteConsoleDisconnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRemoteConsoleDisconnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRemoteConsoleDisconnectedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRemoteConsoleDisconnectedEvent_Def.__bases__: - bases = list(ns0.VmRemoteConsoleDisconnectedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRemoteConsoleDisconnectedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDiscoveredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDiscoveredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDiscoveredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDiscoveredEvent_Def.__bases__: - bases = list(ns0.VmDiscoveredEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDiscoveredEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmOrphanedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmOrphanedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmOrphanedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmOrphanedEvent_Def.__bases__: - bases = list(ns0.VmOrphanedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmOrphanedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmBeingCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmBeingCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmBeingCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmBeingCreatedEvent_Def.__bases__: - bases = list(ns0.VmBeingCreatedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmBeingCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmCreatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmCreatedEvent_Def.__bases__: - bases = list(ns0.VmCreatedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmStartRecordingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmStartRecordingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmStartRecordingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmStartRecordingEvent_Def.__bases__: - bases = list(ns0.VmStartRecordingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmStartRecordingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmEndRecordingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmEndRecordingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmEndRecordingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmEndRecordingEvent_Def.__bases__: - bases = list(ns0.VmEndRecordingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmEndRecordingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmStartReplayingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmStartReplayingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmStartReplayingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmStartReplayingEvent_Def.__bases__: - bases = list(ns0.VmStartReplayingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmStartReplayingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmEndReplayingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmEndReplayingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmEndReplayingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmEndReplayingEvent_Def.__bases__: - bases = list(ns0.VmEndReplayingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmEndReplayingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRegisteredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRegisteredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRegisteredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRegisteredEvent_Def.__bases__: - bases = list(ns0.VmRegisteredEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRegisteredEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmAutoRenameEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmAutoRenameEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmAutoRenameEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmAutoRenameEvent_Def.__bases__: - bases = list(ns0.VmAutoRenameEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmAutoRenameEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmBeingHotMigratedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmBeingHotMigratedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmBeingHotMigratedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmBeingHotMigratedEvent_Def.__bases__: - bases = list(ns0.VmBeingHotMigratedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmBeingHotMigratedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmResettingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmResettingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmResettingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmResettingEvent_Def.__bases__: - bases = list(ns0.VmResettingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmResettingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmStaticMacConflictEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmStaticMacConflictEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmStaticMacConflictEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmStaticMacConflictEvent_Def.__bases__: - bases = list(ns0.VmStaticMacConflictEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmStaticMacConflictEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMacConflictEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMacConflictEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMacConflictEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMacConflictEvent_Def.__bases__: - bases = list(ns0.VmMacConflictEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMacConflictEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmBeingDeployedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmBeingDeployedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmBeingDeployedEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"srcTemplate"), aname="_srcTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmBeingDeployedEvent_Def.__bases__: - bases = list(ns0.VmBeingDeployedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmBeingDeployedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDeployFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDeployFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDeployFailedEvent_Def.schema - TClist = [GTD("urn:vim25","EntityEventArgument",lazy=True)(pname=(ns,"destDatastore"), aname="_destDatastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDeployFailedEvent_Def.__bases__: - bases = list(ns0.VmDeployFailedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDeployFailedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDeployedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDeployedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDeployedEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"srcTemplate"), aname="_srcTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDeployedEvent_Def.__bases__: - bases = list(ns0.VmDeployedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDeployedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMacChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMacChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMacChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"oldMac"), aname="_oldMac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newMac"), aname="_newMac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMacChangedEvent_Def.__bases__: - bases = list(ns0.VmMacChangedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMacChangedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMacAssignedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMacAssignedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMacAssignedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMacAssignedEvent_Def.__bases__: - bases = list(ns0.VmMacAssignedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMacAssignedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmUuidConflictEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmUuidConflictEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmUuidConflictEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmUuidConflictEvent_Def.__bases__: - bases = list(ns0.VmUuidConflictEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmUuidConflictEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmInstanceUuidConflictEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmInstanceUuidConflictEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmInstanceUuidConflictEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVm"), aname="_conflictedVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmInstanceUuidConflictEvent_Def.__bases__: - bases = list(ns0.VmInstanceUuidConflictEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmInstanceUuidConflictEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmBeingMigratedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmBeingMigratedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmBeingMigratedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmBeingMigratedEvent_Def.__bases__: - bases = list(ns0.VmBeingMigratedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmBeingMigratedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedMigrateEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedMigrateEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedMigrateEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedMigrateEvent_Def.__bases__: - bases = list(ns0.VmFailedMigrateEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedMigrateEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMigratedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMigratedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMigratedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"sourceHost"), aname="_sourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMigratedEvent_Def.__bases__: - bases = list(ns0.VmMigratedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMigratedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmUnsupportedStartingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmUnsupportedStartingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmUnsupportedStartingEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmStartingEvent_Def not in ns0.VmUnsupportedStartingEvent_Def.__bases__: - bases = list(ns0.VmUnsupportedStartingEvent_Def.__bases__) - bases.insert(0, ns0.VmStartingEvent_Def) - ns0.VmUnsupportedStartingEvent_Def.__bases__ = tuple(bases) - - ns0.VmStartingEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsVmMigratedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsVmMigratedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsVmMigratedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmMigratedEvent_Def not in ns0.DrsVmMigratedEvent_Def.__bases__: - bases = list(ns0.DrsVmMigratedEvent_Def.__bases__) - bases.insert(0, ns0.VmMigratedEvent_Def) - ns0.DrsVmMigratedEvent_Def.__bases__ = tuple(bases) - - ns0.VmMigratedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsVmPoweredOnEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsVmPoweredOnEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsVmPoweredOnEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmPoweredOnEvent_Def not in ns0.DrsVmPoweredOnEvent_Def.__bases__: - bases = list(ns0.DrsVmPoweredOnEvent_Def.__bases__) - bases.insert(0, ns0.VmPoweredOnEvent_Def) - ns0.DrsVmPoweredOnEvent_Def.__bases__ = tuple(bases) - - ns0.VmPoweredOnEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRelocateSpecEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRelocateSpecEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRelocateSpecEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRelocateSpecEvent_Def.__bases__: - bases = list(ns0.VmRelocateSpecEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRelocateSpecEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmBeingRelocatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmBeingRelocatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmBeingRelocatedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmRelocateSpecEvent_Def not in ns0.VmBeingRelocatedEvent_Def.__bases__: - bases = list(ns0.VmBeingRelocatedEvent_Def.__bases__) - bases.insert(0, ns0.VmRelocateSpecEvent_Def) - ns0.VmBeingRelocatedEvent_Def.__bases__ = tuple(bases) - - ns0.VmRelocateSpecEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRelocatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRelocatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRelocatedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"sourceHost"), aname="_sourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmRelocateSpecEvent_Def not in ns0.VmRelocatedEvent_Def.__bases__: - bases = list(ns0.VmRelocatedEvent_Def.__bases__) - bases.insert(0, ns0.VmRelocateSpecEvent_Def) - ns0.VmRelocatedEvent_Def.__bases__ = tuple(bases) - - ns0.VmRelocateSpecEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRelocateFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRelocateFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRelocateFailedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmRelocateSpecEvent_Def not in ns0.VmRelocateFailedEvent_Def.__bases__: - bases = list(ns0.VmRelocateFailedEvent_Def.__bases__) - bases.insert(0, ns0.VmRelocateSpecEvent_Def) - ns0.VmRelocateFailedEvent_Def.__bases__ = tuple(bases) - - ns0.VmRelocateSpecEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmEmigratingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmEmigratingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmEmigratingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmEmigratingEvent_Def.__bases__: - bases = list(ns0.VmEmigratingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmEmigratingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmCloneEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmCloneEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmCloneEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmCloneEvent_Def.__bases__: - bases = list(ns0.VmCloneEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmCloneEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmBeingClonedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmBeingClonedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmBeingClonedEvent_Def.schema - TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"destFolder"), aname="_destFolder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmCloneEvent_Def not in ns0.VmBeingClonedEvent_Def.__bases__: - bases = list(ns0.VmBeingClonedEvent_Def.__bases__) - bases.insert(0, ns0.VmCloneEvent_Def) - ns0.VmBeingClonedEvent_Def.__bases__ = tuple(bases) - - ns0.VmCloneEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmCloneFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmCloneFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmCloneFailedEvent_Def.schema - TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"destFolder"), aname="_destFolder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destName"), aname="_destName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmCloneEvent_Def not in ns0.VmCloneFailedEvent_Def.__bases__: - bases = list(ns0.VmCloneFailedEvent_Def.__bases__) - bases.insert(0, ns0.VmCloneEvent_Def) - ns0.VmCloneFailedEvent_Def.__bases__ = tuple(bases) - - ns0.VmCloneEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmClonedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmClonedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmClonedEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"sourceVm"), aname="_sourceVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmCloneEvent_Def not in ns0.VmClonedEvent_Def.__bases__: - bases = list(ns0.VmClonedEvent_Def.__bases__) - bases.insert(0, ns0.VmCloneEvent_Def) - ns0.VmClonedEvent_Def.__bases__ = tuple(bases) - - ns0.VmCloneEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmResourceReallocatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmResourceReallocatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmResourceReallocatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmResourceReallocatedEvent_Def.__bases__: - bases = list(ns0.VmResourceReallocatedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmResourceReallocatedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRenamedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRenamedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRenamedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRenamedEvent_Def.__bases__: - bases = list(ns0.VmRenamedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRenamedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDateRolledBackEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDateRolledBackEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDateRolledBackEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDateRolledBackEvent_Def.__bases__: - bases = list(ns0.VmDateRolledBackEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDateRolledBackEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmNoNetworkAccessEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmNoNetworkAccessEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmNoNetworkAccessEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"destHost"), aname="_destHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmNoNetworkAccessEvent_Def.__bases__: - bases = list(ns0.VmNoNetworkAccessEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmNoNetworkAccessEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDiskFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDiskFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDiskFailedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"disk"), aname="_disk", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDiskFailedEvent_Def.__bases__: - bases = list(ns0.VmDiskFailedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDiskFailedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedToPowerOnEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedToPowerOnEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedToPowerOnEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedToPowerOnEvent_Def.__bases__: - bases = list(ns0.VmFailedToPowerOnEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedToPowerOnEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedToPowerOffEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedToPowerOffEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedToPowerOffEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedToPowerOffEvent_Def.__bases__: - bases = list(ns0.VmFailedToPowerOffEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedToPowerOffEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedToSuspendEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedToSuspendEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedToSuspendEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedToSuspendEvent_Def.__bases__: - bases = list(ns0.VmFailedToSuspendEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedToSuspendEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedToResetEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedToResetEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedToResetEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedToResetEvent_Def.__bases__: - bases = list(ns0.VmFailedToResetEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedToResetEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedToShutdownGuestEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedToShutdownGuestEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedToShutdownGuestEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedToShutdownGuestEvent_Def.__bases__: - bases = list(ns0.VmFailedToShutdownGuestEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedToShutdownGuestEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedToRebootGuestEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedToRebootGuestEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedToRebootGuestEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedToRebootGuestEvent_Def.__bases__: - bases = list(ns0.VmFailedToRebootGuestEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedToRebootGuestEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedToStandbyGuestEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedToStandbyGuestEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedToStandbyGuestEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedToStandbyGuestEvent_Def.__bases__: - bases = list(ns0.VmFailedToStandbyGuestEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedToStandbyGuestEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRemovedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRemovedEvent_Def.__bases__: - bases = list(ns0.VmRemovedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmGuestShutdownEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmGuestShutdownEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmGuestShutdownEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmGuestShutdownEvent_Def.__bases__: - bases = list(ns0.VmGuestShutdownEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmGuestShutdownEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmGuestRebootEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmGuestRebootEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmGuestRebootEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmGuestRebootEvent_Def.__bases__: - bases = list(ns0.VmGuestRebootEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmGuestRebootEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmGuestStandbyEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmGuestStandbyEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmGuestStandbyEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmGuestStandbyEvent_Def.__bases__: - bases = list(ns0.VmGuestStandbyEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmGuestStandbyEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmUpgradingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmUpgradingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmUpgradingEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmUpgradingEvent_Def.__bases__: - bases = list(ns0.VmUpgradingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmUpgradingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmUpgradeCompleteEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmUpgradeCompleteEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmUpgradeCompleteEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmUpgradeCompleteEvent_Def.__bases__: - bases = list(ns0.VmUpgradeCompleteEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmUpgradeCompleteEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmUpgradeFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmUpgradeFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmUpgradeFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmUpgradeFailedEvent_Def.__bases__: - bases = list(ns0.VmUpgradeFailedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmUpgradeFailedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRestartedOnAlternateHostEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRestartedOnAlternateHostEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRestartedOnAlternateHostEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"sourceHost"), aname="_sourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmPoweredOnEvent_Def not in ns0.VmRestartedOnAlternateHostEvent_Def.__bases__: - bases = list(ns0.VmRestartedOnAlternateHostEvent_Def.__bases__) - bases.insert(0, ns0.VmPoweredOnEvent_Def) - ns0.VmRestartedOnAlternateHostEvent_Def.__bases__ = tuple(bases) - - ns0.VmPoweredOnEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmReconfiguredEvent_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmReconfiguredEvent_Def.__bases__: - bases = list(ns0.VmReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMessageEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMessageEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMessageEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"messageInfo"), aname="_messageInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMessageEvent_Def.__bases__: - bases = list(ns0.VmMessageEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMessageEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMessageWarningEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMessageWarningEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMessageWarningEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"messageInfo"), aname="_messageInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMessageWarningEvent_Def.__bases__: - bases = list(ns0.VmMessageWarningEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMessageWarningEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMessageErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMessageErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMessageErrorEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"messageInfo"), aname="_messageInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMessageErrorEvent_Def.__bases__: - bases = list(ns0.VmMessageErrorEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMessageErrorEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigMissingEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigMissingEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigMissingEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmConfigMissingEvent_Def.__bases__: - bases = list(ns0.VmConfigMissingEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmConfigMissingEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmPowerOffOnIsolationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmPowerOffOnIsolationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmPowerOffOnIsolationEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"isolatedHost"), aname="_isolatedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmPoweredOffEvent_Def not in ns0.VmPowerOffOnIsolationEvent_Def.__bases__: - bases = list(ns0.VmPowerOffOnIsolationEvent_Def.__bases__) - bases.insert(0, ns0.VmPoweredOffEvent_Def) - ns0.VmPowerOffOnIsolationEvent_Def.__bases__ = tuple(bases) - - ns0.VmPoweredOffEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmShutdownOnIsolationEventOperation_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VmShutdownOnIsolationEventOperation") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VmShutdownOnIsolationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmShutdownOnIsolationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmShutdownOnIsolationEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"isolatedHost"), aname="_isolatedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"shutdownResult"), aname="_shutdownResult", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmPoweredOffEvent_Def not in ns0.VmShutdownOnIsolationEvent_Def.__bases__: - bases = list(ns0.VmShutdownOnIsolationEvent_Def.__bases__) - bases.insert(0, ns0.VmPoweredOffEvent_Def) - ns0.VmShutdownOnIsolationEvent_Def.__bases__ = tuple(bases) - - ns0.VmPoweredOffEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailoverFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailoverFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailoverFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailoverFailed_Def.__bases__: - bases = list(ns0.VmFailoverFailed_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailoverFailed_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDasBeingResetEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDasBeingResetEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDasBeingResetEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDasBeingResetEvent_Def.__bases__: - bases = list(ns0.VmDasBeingResetEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDasBeingResetEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDasResetFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDasResetFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDasResetFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDasResetFailedEvent_Def.__bases__: - bases = list(ns0.VmDasResetFailedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDasResetFailedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMaxRestartCountReached_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMaxRestartCountReached") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMaxRestartCountReached_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMaxRestartCountReached_Def.__bases__: - bases = list(ns0.VmMaxRestartCountReached_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMaxRestartCountReached_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmMaxFTRestartCountReached_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmMaxFTRestartCountReached") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmMaxFTRestartCountReached_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmMaxFTRestartCountReached_Def.__bases__: - bases = list(ns0.VmMaxFTRestartCountReached_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmMaxFTRestartCountReached_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDasBeingResetWithScreenshotEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDasBeingResetWithScreenshotEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDasBeingResetWithScreenshotEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"screenshotFilePath"), aname="_screenshotFilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmDasBeingResetEvent_Def not in ns0.VmDasBeingResetWithScreenshotEvent_Def.__bases__: - bases = list(ns0.VmDasBeingResetWithScreenshotEvent_Def.__bases__) - bases.insert(0, ns0.VmDasBeingResetEvent_Def) - ns0.VmDasBeingResetWithScreenshotEvent_Def.__bases__ = tuple(bases) - - ns0.VmDasBeingResetEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotEnoughResourcesToStartVmEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotEnoughResourcesToStartVmEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotEnoughResourcesToStartVmEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.NotEnoughResourcesToStartVmEvent_Def.__bases__: - bases = list(ns0.NotEnoughResourcesToStartVmEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.NotEnoughResourcesToStartVmEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmUuidAssignedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmUuidAssignedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmUuidAssignedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmUuidAssignedEvent_Def.__bases__: - bases = list(ns0.VmUuidAssignedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmUuidAssignedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmInstanceUuidAssignedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmInstanceUuidAssignedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmInstanceUuidAssignedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmInstanceUuidAssignedEvent_Def.__bases__: - bases = list(ns0.VmInstanceUuidAssignedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmInstanceUuidAssignedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmUuidChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmUuidChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmUuidChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldUuid"), aname="_oldUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newUuid"), aname="_newUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmUuidChangedEvent_Def.__bases__: - bases = list(ns0.VmUuidChangedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmUuidChangedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmInstanceUuidChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmInstanceUuidChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmInstanceUuidChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldInstanceUuid"), aname="_oldInstanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newInstanceUuid"), aname="_newInstanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmInstanceUuidChangedEvent_Def.__bases__: - bases = list(ns0.VmInstanceUuidChangedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmInstanceUuidChangedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmWwnConflictEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmWwnConflictEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmWwnConflictEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVms"), aname="_conflictedVms", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"conflictedHosts"), aname="_conflictedHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"wwn"), aname="_wwn", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmWwnConflictEvent_Def.__bases__: - bases = list(ns0.VmWwnConflictEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmWwnConflictEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmAcquiredMksTicketEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmAcquiredMksTicketEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmAcquiredMksTicketEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmAcquiredMksTicketEvent_Def.__bases__: - bases = list(ns0.VmAcquiredMksTicketEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmAcquiredMksTicketEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostWwnConflictEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostWwnConflictEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostWwnConflictEvent_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"conflictedVms"), aname="_conflictedVms", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"conflictedHosts"), aname="_conflictedHosts", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"wwn"), aname="_wwn", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostWwnConflictEvent_Def.__bases__: - bases = list(ns0.HostWwnConflictEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostWwnConflictEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmWwnAssignedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmWwnAssignedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmWwnAssignedEvent_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"nodeWwns"), aname="_nodeWwns", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"portWwns"), aname="_portWwns", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmWwnAssignedEvent_Def.__bases__: - bases = list(ns0.VmWwnAssignedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmWwnAssignedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmWwnChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmWwnChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmWwnChangedEvent_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"oldNodeWwns"), aname="_oldNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"oldPortWwns"), aname="_oldPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newNodeWwns"), aname="_newNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newPortWwns"), aname="_newPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmWwnChangedEvent_Def.__bases__: - bases = list(ns0.VmWwnChangedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmWwnChangedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSecondaryAddedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSecondaryAddedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSecondaryAddedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmSecondaryAddedEvent_Def.__bases__: - bases = list(ns0.VmSecondaryAddedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmSecondaryAddedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFaultToleranceTurnedOffEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFaultToleranceTurnedOffEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFaultToleranceTurnedOffEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFaultToleranceTurnedOffEvent_Def.__bases__: - bases = list(ns0.VmFaultToleranceTurnedOffEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFaultToleranceTurnedOffEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFaultToleranceStateChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFaultToleranceStateChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFaultToleranceStateChangedEvent_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFaultToleranceState",lazy=True)(pname=(ns,"oldState"), aname="_oldState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFaultToleranceState",lazy=True)(pname=(ns,"newState"), aname="_newState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFaultToleranceStateChangedEvent_Def.__bases__: - bases = list(ns0.VmFaultToleranceStateChangedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFaultToleranceStateChangedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSecondaryDisabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSecondaryDisabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSecondaryDisabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmSecondaryDisabledEvent_Def.__bases__: - bases = list(ns0.VmSecondaryDisabledEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmSecondaryDisabledEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSecondaryDisabledBySystemEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSecondaryDisabledBySystemEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSecondaryDisabledBySystemEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmSecondaryDisabledBySystemEvent_Def.__bases__: - bases = list(ns0.VmSecondaryDisabledBySystemEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmSecondaryDisabledBySystemEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSecondaryEnabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSecondaryEnabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSecondaryEnabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmSecondaryEnabledEvent_Def.__bases__: - bases = list(ns0.VmSecondaryEnabledEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmSecondaryEnabledEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmStartingSecondaryEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmStartingSecondaryEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmStartingSecondaryEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmStartingSecondaryEvent_Def.__bases__: - bases = list(ns0.VmStartingSecondaryEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmStartingSecondaryEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSecondaryStartedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSecondaryStartedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSecondaryStartedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmSecondaryStartedEvent_Def.__bases__: - bases = list(ns0.VmSecondaryStartedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmSecondaryStartedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedUpdatingSecondaryConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedUpdatingSecondaryConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedUpdatingSecondaryConfig_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedUpdatingSecondaryConfig_Def.__bases__: - bases = list(ns0.VmFailedUpdatingSecondaryConfig_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedUpdatingSecondaryConfig_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedStartingSecondaryEventFailureReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VmFailedStartingSecondaryEventFailureReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VmFailedStartingSecondaryEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedStartingSecondaryEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedStartingSecondaryEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedStartingSecondaryEvent_Def.__bases__: - bases = list(ns0.VmFailedStartingSecondaryEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedStartingSecondaryEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmTimedoutStartingSecondaryEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmTimedoutStartingSecondaryEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmTimedoutStartingSecondaryEvent_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"timeout"), aname="_timeout", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmTimedoutStartingSecondaryEvent_Def.__bases__: - bases = list(ns0.VmTimedoutStartingSecondaryEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmTimedoutStartingSecondaryEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmNoCompatibleHostForSecondaryEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmNoCompatibleHostForSecondaryEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmNoCompatibleHostForSecondaryEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmNoCompatibleHostForSecondaryEvent_Def.__bases__: - bases = list(ns0.VmNoCompatibleHostForSecondaryEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmNoCompatibleHostForSecondaryEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmPrimaryFailoverEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmPrimaryFailoverEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmPrimaryFailoverEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmPrimaryFailoverEvent_Def.__bases__: - bases = list(ns0.VmPrimaryFailoverEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmPrimaryFailoverEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFaultToleranceVmTerminatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFaultToleranceVmTerminatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFaultToleranceVmTerminatedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFaultToleranceVmTerminatedEvent_Def.__bases__: - bases = list(ns0.VmFaultToleranceVmTerminatedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFaultToleranceVmTerminatedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostWwnChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostWwnChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostWwnChangedEvent_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"oldNodeWwns"), aname="_oldNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"oldPortWwns"), aname="_oldPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newNodeWwns"), aname="_newNodeWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newPortWwns"), aname="_newPortWwns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostWwnChangedEvent_Def.__bases__: - bases = list(ns0.HostWwnChangedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostWwnChangedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostAdminDisableEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostAdminDisableEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostAdminDisableEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostAdminDisableEvent_Def.__bases__: - bases = list(ns0.HostAdminDisableEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostAdminDisableEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostAdminEnableEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostAdminEnableEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostAdminEnableEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostAdminEnableEvent_Def.__bases__: - bases = list(ns0.HostAdminEnableEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostAdminEnableEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostEnableAdminFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostEnableAdminFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostEnableAdminFailedEvent_Def.schema - TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"permissions"), aname="_permissions", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.HostEnableAdminFailedEvent_Def.__bases__: - bases = list(ns0.HostEnableAdminFailedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.HostEnableAdminFailedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedRelayoutOnVmfs2DatastoreEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedRelayoutOnVmfs2DatastoreEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.__bases__: - bases = list(ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedRelayoutOnVmfs2DatastoreEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFailedRelayoutEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFailedRelayoutEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFailedRelayoutEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmFailedRelayoutEvent_Def.__bases__: - bases = list(ns0.VmFailedRelayoutEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmFailedRelayoutEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRelayoutSuccessfulEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRelayoutSuccessfulEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRelayoutSuccessfulEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRelayoutSuccessfulEvent_Def.__bases__: - bases = list(ns0.VmRelayoutSuccessfulEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRelayoutSuccessfulEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmRelayoutUpToDateEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmRelayoutUpToDateEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmRelayoutUpToDateEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmRelayoutUpToDateEvent_Def.__bases__: - bases = list(ns0.VmRelayoutUpToDateEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmRelayoutUpToDateEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConnectedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmConnectedEvent_Def.__bases__: - bases = list(ns0.VmConnectedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmConnectedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmPoweringOnWithCustomizedDVPortEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmPoweringOnWithCustomizedDVPortEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.schema - TClist = [GTD("urn:vim25","VnicPortArgument",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.__bases__: - bases = list(ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmPoweringOnWithCustomizedDVPortEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDasUpdateErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDasUpdateErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDasUpdateErrorEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDasUpdateErrorEvent_Def.__bases__: - bases = list(ns0.VmDasUpdateErrorEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDasUpdateErrorEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoMaintenanceModeDrsRecommendationForVM_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoMaintenanceModeDrsRecommendationForVM") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoMaintenanceModeDrsRecommendationForVM_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.NoMaintenanceModeDrsRecommendationForVM_Def.__bases__: - bases = list(ns0.NoMaintenanceModeDrsRecommendationForVM_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.NoMaintenanceModeDrsRecommendationForVM_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDasUpdateOkEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDasUpdateOkEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDasUpdateOkEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmDasUpdateOkEvent_Def.__bases__: - bases = list(ns0.VmDasUpdateOkEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmDasUpdateOkEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskEvent_Def.schema - TClist = [GTD("urn:vim25","ScheduledTaskEventArgument",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.ScheduledTaskEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.ScheduledTaskEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskCreatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskCreatedEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskCreatedEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskStartedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskStartedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskStartedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskStartedEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskStartedEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskStartedEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskRemovedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskRemovedEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskRemovedEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskReconfiguredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskReconfiguredEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskCompletedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskCompletedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskCompletedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskCompletedEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskCompletedEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskCompletedEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskFailedEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskFailedEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskFailedEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskFailedEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskEmailCompletedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskEmailCompletedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskEmailCompletedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskEmailCompletedEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskEmailCompletedEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskEmailCompletedEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskEmailFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskEmailFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskEmailFailedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskEvent_Def not in ns0.ScheduledTaskEmailFailedEvent_Def.__bases__: - bases = list(ns0.ScheduledTaskEmailFailedEvent_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskEvent_Def) - ns0.ScheduledTaskEmailFailedEvent_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmEvent_Def.schema - TClist = [GTD("urn:vim25","AlarmEventArgument",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.AlarmEvent_Def.__bases__: - bases = list(ns0.AlarmEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.AlarmEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmCreatedEvent_Def.__bases__: - bases = list(ns0.AlarmCreatedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmStatusChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmStatusChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmStatusChangedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"from"), aname="_from", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmStatusChangedEvent_Def.__bases__: - bases = list(ns0.AlarmStatusChangedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmStatusChangedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmActionTriggeredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmActionTriggeredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmActionTriggeredEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmActionTriggeredEvent_Def.__bases__: - bases = list(ns0.AlarmActionTriggeredEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmActionTriggeredEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmEmailCompletedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmEmailCompletedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmEmailCompletedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmEmailCompletedEvent_Def.__bases__: - bases = list(ns0.AlarmEmailCompletedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmEmailCompletedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmEmailFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmEmailFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmEmailFailedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"to"), aname="_to", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmEmailFailedEvent_Def.__bases__: - bases = list(ns0.AlarmEmailFailedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmEmailFailedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmSnmpCompletedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmSnmpCompletedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmSnmpCompletedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmSnmpCompletedEvent_Def.__bases__: - bases = list(ns0.AlarmSnmpCompletedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmSnmpCompletedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmSnmpFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmSnmpFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmSnmpFailedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmSnmpFailedEvent_Def.__bases__: - bases = list(ns0.AlarmSnmpFailedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmSnmpFailedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmScriptCompleteEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmScriptCompleteEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmScriptCompleteEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"script"), aname="_script", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmScriptCompleteEvent_Def.__bases__: - bases = list(ns0.AlarmScriptCompleteEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmScriptCompleteEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmScriptFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmScriptFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmScriptFailedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"script"), aname="_script", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmScriptFailedEvent_Def.__bases__: - bases = list(ns0.AlarmScriptFailedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmScriptFailedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmRemovedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmRemovedEvent_Def.__bases__: - bases = list(ns0.AlarmRemovedEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmReconfiguredEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AlarmEvent_Def not in ns0.AlarmReconfiguredEvent_Def.__bases__: - bases = list(ns0.AlarmReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.AlarmEvent_Def) - ns0.AlarmReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.AlarmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomFieldEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.CustomFieldEvent_Def.__bases__: - bases = list(ns0.CustomFieldEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.CustomFieldEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomFieldDefEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldDefEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldDefEvent_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"fieldKey"), aname="_fieldKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomFieldEvent_Def not in ns0.CustomFieldDefEvent_Def.__bases__: - bases = list(ns0.CustomFieldDefEvent_Def.__bases__) - bases.insert(0, ns0.CustomFieldEvent_Def) - ns0.CustomFieldDefEvent_Def.__bases__ = tuple(bases) - - ns0.CustomFieldEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomFieldDefAddedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldDefAddedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldDefAddedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomFieldDefEvent_Def not in ns0.CustomFieldDefAddedEvent_Def.__bases__: - bases = list(ns0.CustomFieldDefAddedEvent_Def.__bases__) - bases.insert(0, ns0.CustomFieldDefEvent_Def) - ns0.CustomFieldDefAddedEvent_Def.__bases__ = tuple(bases) - - ns0.CustomFieldDefEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomFieldDefRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldDefRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldDefRemovedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomFieldDefEvent_Def not in ns0.CustomFieldDefRemovedEvent_Def.__bases__: - bases = list(ns0.CustomFieldDefRemovedEvent_Def.__bases__) - bases.insert(0, ns0.CustomFieldDefEvent_Def) - ns0.CustomFieldDefRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.CustomFieldDefEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomFieldDefRenamedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldDefRenamedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldDefRenamedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomFieldDefEvent_Def not in ns0.CustomFieldDefRenamedEvent_Def.__bases__: - bases = list(ns0.CustomFieldDefRenamedEvent_Def.__bases__) - bases.insert(0, ns0.CustomFieldDefEvent_Def) - ns0.CustomFieldDefRenamedEvent_Def.__bases__ = tuple(bases) - - ns0.CustomFieldDefEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomFieldValueChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomFieldValueChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomFieldValueChangedEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"fieldKey"), aname="_fieldKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomFieldEvent_Def not in ns0.CustomFieldValueChangedEvent_Def.__bases__: - bases = list(ns0.CustomFieldValueChangedEvent_Def.__bases__) - bases.insert(0, ns0.CustomFieldEvent_Def) - ns0.CustomFieldValueChangedEvent_Def.__bases__ = tuple(bases) - - ns0.CustomFieldEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AuthorizationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AuthorizationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AuthorizationEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.AuthorizationEvent_Def.__bases__: - bases = list(ns0.AuthorizationEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.AuthorizationEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PermissionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PermissionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PermissionEvent_Def.schema - TClist = [GTD("urn:vim25","ManagedEntityEventArgument",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AuthorizationEvent_Def not in ns0.PermissionEvent_Def.__bases__: - bases = list(ns0.PermissionEvent_Def.__bases__) - bases.insert(0, ns0.AuthorizationEvent_Def) - ns0.PermissionEvent_Def.__bases__ = tuple(bases) - - ns0.AuthorizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PermissionAddedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PermissionAddedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PermissionAddedEvent_Def.schema - TClist = [GTD("urn:vim25","RoleEventArgument",lazy=True)(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"propagate"), aname="_propagate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PermissionEvent_Def not in ns0.PermissionAddedEvent_Def.__bases__: - bases = list(ns0.PermissionAddedEvent_Def.__bases__) - bases.insert(0, ns0.PermissionEvent_Def) - ns0.PermissionAddedEvent_Def.__bases__ = tuple(bases) - - ns0.PermissionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PermissionUpdatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PermissionUpdatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PermissionUpdatedEvent_Def.schema - TClist = [GTD("urn:vim25","RoleEventArgument",lazy=True)(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"propagate"), aname="_propagate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PermissionEvent_Def not in ns0.PermissionUpdatedEvent_Def.__bases__: - bases = list(ns0.PermissionUpdatedEvent_Def.__bases__) - bases.insert(0, ns0.PermissionEvent_Def) - ns0.PermissionUpdatedEvent_Def.__bases__ = tuple(bases) - - ns0.PermissionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PermissionRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PermissionRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PermissionRemovedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PermissionEvent_Def not in ns0.PermissionRemovedEvent_Def.__bases__: - bases = list(ns0.PermissionRemovedEvent_Def.__bases__) - bases.insert(0, ns0.PermissionEvent_Def) - ns0.PermissionRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.PermissionEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RoleEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RoleEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RoleEvent_Def.schema - TClist = [GTD("urn:vim25","RoleEventArgument",lazy=True)(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.AuthorizationEvent_Def not in ns0.RoleEvent_Def.__bases__: - bases = list(ns0.RoleEvent_Def.__bases__) - bases.insert(0, ns0.AuthorizationEvent_Def) - ns0.RoleEvent_Def.__bases__ = tuple(bases) - - ns0.AuthorizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RoleAddedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RoleAddedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RoleAddedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"privilegeList"), aname="_privilegeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RoleEvent_Def not in ns0.RoleAddedEvent_Def.__bases__: - bases = list(ns0.RoleAddedEvent_Def.__bases__) - bases.insert(0, ns0.RoleEvent_Def) - ns0.RoleAddedEvent_Def.__bases__ = tuple(bases) - - ns0.RoleEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RoleUpdatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RoleUpdatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RoleUpdatedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"privilegeList"), aname="_privilegeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RoleEvent_Def not in ns0.RoleUpdatedEvent_Def.__bases__: - bases = list(ns0.RoleUpdatedEvent_Def.__bases__) - bases.insert(0, ns0.RoleEvent_Def) - ns0.RoleUpdatedEvent_Def.__bases__ = tuple(bases) - - ns0.RoleEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RoleRemovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RoleRemovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RoleRemovedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RoleEvent_Def not in ns0.RoleRemovedEvent_Def.__bases__: - bases = list(ns0.RoleRemovedEvent_Def.__bases__) - bases.insert(0, ns0.RoleEvent_Def) - ns0.RoleRemovedEvent_Def.__bases__ = tuple(bases) - - ns0.RoleEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.DatastoreEvent_Def.__bases__: - bases = list(ns0.DatastoreEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.DatastoreEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreDestroyedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreDestroyedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreDestroyedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreEvent_Def not in ns0.DatastoreDestroyedEvent_Def.__bases__: - bases = list(ns0.DatastoreDestroyedEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreEvent_Def) - ns0.DatastoreDestroyedEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreRenamedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreRenamedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreRenamedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreEvent_Def not in ns0.DatastoreRenamedEvent_Def.__bases__: - bases = list(ns0.DatastoreRenamedEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreEvent_Def) - ns0.DatastoreRenamedEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreCapacityIncreasedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreCapacityIncreasedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreCapacityIncreasedEvent_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"oldCapacity"), aname="_oldCapacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"newCapacity"), aname="_newCapacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreEvent_Def not in ns0.DatastoreCapacityIncreasedEvent_Def.__bases__: - bases = list(ns0.DatastoreCapacityIncreasedEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreEvent_Def) - ns0.DatastoreCapacityIncreasedEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreDuplicatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreDuplicatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreDuplicatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreEvent_Def not in ns0.DatastoreDuplicatedEvent_Def.__bases__: - bases = list(ns0.DatastoreDuplicatedEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreEvent_Def) - ns0.DatastoreDuplicatedEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreFileEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreFileEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreFileEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"targetFile"), aname="_targetFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreEvent_Def not in ns0.DatastoreFileEvent_Def.__bases__: - bases = list(ns0.DatastoreFileEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreEvent_Def) - ns0.DatastoreFileEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreFileCopiedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreFileCopiedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreFileCopiedEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"sourceDatastore"), aname="_sourceDatastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceFile"), aname="_sourceFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreFileEvent_Def not in ns0.DatastoreFileCopiedEvent_Def.__bases__: - bases = list(ns0.DatastoreFileCopiedEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreFileEvent_Def) - ns0.DatastoreFileCopiedEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreFileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreFileMovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreFileMovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreFileMovedEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"sourceDatastore"), aname="_sourceDatastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sourceFile"), aname="_sourceFile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreFileEvent_Def not in ns0.DatastoreFileMovedEvent_Def.__bases__: - bases = list(ns0.DatastoreFileMovedEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreFileEvent_Def) - ns0.DatastoreFileMovedEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreFileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreFileDeletedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreFileDeletedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreFileDeletedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreFileEvent_Def not in ns0.DatastoreFileDeletedEvent_Def.__bases__: - bases = list(ns0.DatastoreFileDeletedEvent_Def.__bases__) - bases.insert(0, ns0.DatastoreFileEvent_Def) - ns0.DatastoreFileDeletedEvent_Def.__bases__ = tuple(bases) - - ns0.DatastoreFileEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskEvent_Def.schema - TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.TaskEvent_Def.__bases__: - bases = list(ns0.TaskEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.TaskEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskTimeoutEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskTimeoutEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskTimeoutEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskEvent_Def not in ns0.TaskTimeoutEvent_Def.__bases__: - bases = list(ns0.TaskTimeoutEvent_Def.__bases__) - bases.insert(0, ns0.TaskEvent_Def) - ns0.TaskTimeoutEvent_Def.__bases__ = tuple(bases) - - ns0.TaskEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.LicenseEvent_Def.__bases__: - bases = list(ns0.LicenseEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.LicenseEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ServerLicenseExpiredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ServerLicenseExpiredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ServerLicenseExpiredEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"product"), aname="_product", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.ServerLicenseExpiredEvent_Def.__bases__: - bases = list(ns0.ServerLicenseExpiredEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.ServerLicenseExpiredEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostLicenseExpiredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostLicenseExpiredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostLicenseExpiredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.HostLicenseExpiredEvent_Def.__bases__: - bases = list(ns0.HostLicenseExpiredEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.HostLicenseExpiredEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionLicenseExpiredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionLicenseExpiredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionLicenseExpiredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.VMotionLicenseExpiredEvent_Def.__bases__: - bases = list(ns0.VMotionLicenseExpiredEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.VMotionLicenseExpiredEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoLicenseEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoLicenseEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoLicenseEvent_Def.schema - TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.NoLicenseEvent_Def.__bases__: - bases = list(ns0.NoLicenseEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.NoLicenseEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseServerUnavailableEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseServerUnavailableEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseServerUnavailableEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.LicenseServerUnavailableEvent_Def.__bases__: - bases = list(ns0.LicenseServerUnavailableEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.LicenseServerUnavailableEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseServerAvailableEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseServerAvailableEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseServerAvailableEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.LicenseServerAvailableEvent_Def.__bases__: - bases = list(ns0.LicenseServerAvailableEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.LicenseServerAvailableEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseExpiredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseExpiredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseExpiredEvent_Def.schema - TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.LicenseExpiredEvent_Def.__bases__: - bases = list(ns0.LicenseExpiredEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.LicenseExpiredEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidEditionEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidEditionEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidEditionEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.InvalidEditionEvent_Def.__bases__: - bases = list(ns0.InvalidEditionEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.InvalidEditionEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInventoryFullEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInventoryFullEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInventoryFullEvent_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.HostInventoryFullEvent_Def.__bases__: - bases = list(ns0.HostInventoryFullEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.HostInventoryFullEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseRestrictedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseRestrictedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseRestrictedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.LicenseRestrictedEvent_Def.__bases__: - bases = list(ns0.LicenseRestrictedEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.LicenseRestrictedEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IncorrectHostInformationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IncorrectHostInformationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IncorrectHostInformationEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.IncorrectHostInformationEvent_Def.__bases__: - bases = list(ns0.IncorrectHostInformationEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.IncorrectHostInformationEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnlicensedVirtualMachinesEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnlicensedVirtualMachinesEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnlicensedVirtualMachinesEvent_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"unlicensed"), aname="_unlicensed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.UnlicensedVirtualMachinesEvent_Def.__bases__: - bases = list(ns0.UnlicensedVirtualMachinesEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.UnlicensedVirtualMachinesEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnlicensedVirtualMachinesFoundEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnlicensedVirtualMachinesFoundEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnlicensedVirtualMachinesFoundEvent_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.UnlicensedVirtualMachinesFoundEvent_Def.__bases__: - bases = list(ns0.UnlicensedVirtualMachinesFoundEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.UnlicensedVirtualMachinesFoundEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AllVirtualMachinesLicensedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AllVirtualMachinesLicensedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AllVirtualMachinesLicensedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.AllVirtualMachinesLicensedEvent_Def.__bases__: - bases = list(ns0.AllVirtualMachinesLicensedEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.AllVirtualMachinesLicensedEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseNonComplianceEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseNonComplianceEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseNonComplianceEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.LicenseEvent_Def not in ns0.LicenseNonComplianceEvent_Def.__bases__: - bases = list(ns0.LicenseNonComplianceEvent_Def.__bases__) - bases.insert(0, ns0.LicenseEvent_Def) - ns0.LicenseNonComplianceEvent_Def.__bases__ = tuple(bases) - - ns0.LicenseEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.MigrationEvent_Def.__bases__: - bases = list(ns0.MigrationEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.MigrationEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationWarningEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationWarningEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationWarningEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationEvent_Def not in ns0.MigrationWarningEvent_Def.__bases__: - bases = list(ns0.MigrationWarningEvent_Def.__bases__) - bases.insert(0, ns0.MigrationEvent_Def) - ns0.MigrationWarningEvent_Def.__bases__ = tuple(bases) - - ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationErrorEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationEvent_Def not in ns0.MigrationErrorEvent_Def.__bases__: - bases = list(ns0.MigrationErrorEvent_Def.__bases__) - bases.insert(0, ns0.MigrationEvent_Def) - ns0.MigrationErrorEvent_Def.__bases__ = tuple(bases) - - ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationHostWarningEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationHostWarningEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationHostWarningEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationEvent_Def not in ns0.MigrationHostWarningEvent_Def.__bases__: - bases = list(ns0.MigrationHostWarningEvent_Def.__bases__) - bases.insert(0, ns0.MigrationEvent_Def) - ns0.MigrationHostWarningEvent_Def.__bases__ = tuple(bases) - - ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationHostErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationHostErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationHostErrorEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationEvent_Def not in ns0.MigrationHostErrorEvent_Def.__bases__: - bases = list(ns0.MigrationHostErrorEvent_Def.__bases__) - bases.insert(0, ns0.MigrationEvent_Def) - ns0.MigrationHostErrorEvent_Def.__bases__ = tuple(bases) - - ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationResourceWarningEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationResourceWarningEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationResourceWarningEvent_Def.schema - TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"dstPool"), aname="_dstPool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationEvent_Def not in ns0.MigrationResourceWarningEvent_Def.__bases__: - bases = list(ns0.MigrationResourceWarningEvent_Def.__bases__) - bases.insert(0, ns0.MigrationEvent_Def) - ns0.MigrationResourceWarningEvent_Def.__bases__ = tuple(bases) - - ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationResourceErrorEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationResourceErrorEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationResourceErrorEvent_Def.schema - TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"dstPool"), aname="_dstPool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"dstHost"), aname="_dstHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationEvent_Def not in ns0.MigrationResourceErrorEvent_Def.__bases__: - bases = list(ns0.MigrationResourceErrorEvent_Def.__bases__) - bases.insert(0, ns0.MigrationEvent_Def) - ns0.MigrationResourceErrorEvent_Def.__bases__ = tuple(bases) - - ns0.MigrationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.ClusterEvent_Def.__bases__: - bases = list(ns0.ClusterEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.ClusterEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasEnabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasEnabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasEnabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasEnabledEvent_Def.__bases__: - bases = list(ns0.DasEnabledEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasEnabledEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasDisabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasDisabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasDisabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasDisabledEvent_Def.__bases__: - bases = list(ns0.DasDisabledEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasDisabledEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasAdmissionControlDisabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasAdmissionControlDisabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasAdmissionControlDisabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasAdmissionControlDisabledEvent_Def.__bases__: - bases = list(ns0.DasAdmissionControlDisabledEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasAdmissionControlDisabledEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasAdmissionControlEnabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasAdmissionControlEnabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasAdmissionControlEnabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasAdmissionControlEnabledEvent_Def.__bases__: - bases = list(ns0.DasAdmissionControlEnabledEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasAdmissionControlEnabledEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasHostFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasHostFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasHostFailedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"failedHost"), aname="_failedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasHostFailedEvent_Def.__bases__: - bases = list(ns0.DasHostFailedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasHostFailedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasHostIsolatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasHostIsolatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasHostIsolatedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"isolatedHost"), aname="_isolatedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasHostIsolatedEvent_Def.__bases__: - bases = list(ns0.DasHostIsolatedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasHostIsolatedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasClusterIsolatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasClusterIsolatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasClusterIsolatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasClusterIsolatedEvent_Def.__bases__: - bases = list(ns0.DasClusterIsolatedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasClusterIsolatedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasAgentUnavailableEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasAgentUnavailableEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasAgentUnavailableEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasAgentUnavailableEvent_Def.__bases__: - bases = list(ns0.DasAgentUnavailableEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasAgentUnavailableEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasAgentFoundEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasAgentFoundEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasAgentFoundEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DasAgentFoundEvent_Def.__bases__: - bases = list(ns0.DasAgentFoundEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DasAgentFoundEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientFailoverResourcesEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientFailoverResourcesEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientFailoverResourcesEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.InsufficientFailoverResourcesEvent_Def.__bases__: - bases = list(ns0.InsufficientFailoverResourcesEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.InsufficientFailoverResourcesEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FailoverLevelRestored_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FailoverLevelRestored") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FailoverLevelRestored_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.FailoverLevelRestored_Def.__bases__: - bases = list(ns0.FailoverLevelRestored_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.FailoverLevelRestored_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterOvercommittedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterOvercommittedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterOvercommittedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.ClusterOvercommittedEvent_Def.__bases__: - bases = list(ns0.ClusterOvercommittedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.ClusterOvercommittedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostOvercommittedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostOvercommittedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostOvercommittedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterOvercommittedEvent_Def not in ns0.HostOvercommittedEvent_Def.__bases__: - bases = list(ns0.HostOvercommittedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterOvercommittedEvent_Def) - ns0.HostOvercommittedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterOvercommittedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterStatusChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterStatusChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterStatusChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldStatus"), aname="_oldStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newStatus"), aname="_newStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.ClusterStatusChangedEvent_Def.__bases__: - bases = list(ns0.ClusterStatusChangedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.ClusterStatusChangedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostStatusChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostStatusChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostStatusChangedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterStatusChangedEvent_Def not in ns0.HostStatusChangedEvent_Def.__bases__: - bases = list(ns0.HostStatusChangedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterStatusChangedEvent_Def) - ns0.HostStatusChangedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterStatusChangedEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.ClusterCreatedEvent_Def.__bases__: - bases = list(ns0.ClusterCreatedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.ClusterCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterDestroyedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterDestroyedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterDestroyedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.ClusterDestroyedEvent_Def.__bases__: - bases = list(ns0.ClusterDestroyedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.ClusterDestroyedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsEnabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsEnabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsEnabledEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"behavior"), aname="_behavior", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DrsEnabledEvent_Def.__bases__: - bases = list(ns0.DrsEnabledEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DrsEnabledEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsDisabledEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsDisabledEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsDisabledEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DrsDisabledEvent_Def.__bases__: - bases = list(ns0.DrsDisabledEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DrsDisabledEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterReconfiguredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.ClusterReconfiguredEvent_Def.__bases__: - bases = list(ns0.ClusterReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.ClusterReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostMonitoringStateChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMonitoringStateChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMonitoringStateChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.HostMonitoringStateChangedEvent_Def.__bases__: - bases = list(ns0.HostMonitoringStateChangedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.HostMonitoringStateChangedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmHealthMonitoringStateChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmHealthMonitoringStateChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmHealthMonitoringStateChangedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.VmHealthMonitoringStateChangedEvent_Def.__bases__: - bases = list(ns0.VmHealthMonitoringStateChangedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.VmHealthMonitoringStateChangedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolEvent_Def.schema - TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.ResourcePoolEvent_Def.__bases__: - bases = list(ns0.ResourcePoolEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.ResourcePoolEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolCreatedEvent_Def.__bases__: - bases = list(ns0.ResourcePoolCreatedEvent_Def.__bases__) - bases.insert(0, ns0.ResourcePoolEvent_Def) - ns0.ResourcePoolCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolDestroyedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolDestroyedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolDestroyedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolDestroyedEvent_Def.__bases__: - bases = list(ns0.ResourcePoolDestroyedEvent_Def.__bases__) - bases.insert(0, ns0.ResourcePoolEvent_Def) - ns0.ResourcePoolDestroyedEvent_Def.__bases__ = tuple(bases) - - ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolMovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolMovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolMovedEvent_Def.schema - TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"oldParent"), aname="_oldParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"newParent"), aname="_newParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolMovedEvent_Def.__bases__: - bases = list(ns0.ResourcePoolMovedEvent_Def.__bases__) - bases.insert(0, ns0.ResourcePoolEvent_Def) - ns0.ResourcePoolMovedEvent_Def.__bases__ = tuple(bases) - - ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolReconfiguredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ResourcePoolEvent_Def not in ns0.ResourcePoolReconfiguredEvent_Def.__bases__: - bases = list(ns0.ResourcePoolReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.ResourcePoolEvent_Def) - ns0.ResourcePoolReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourceViolatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourceViolatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourceViolatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ResourcePoolEvent_Def not in ns0.ResourceViolatedEvent_Def.__bases__: - bases = list(ns0.ResourceViolatedEvent_Def.__bases__) - bases.insert(0, ns0.ResourcePoolEvent_Def) - ns0.ResourceViolatedEvent_Def.__bases__ = tuple(bases) - - ns0.ResourcePoolEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmResourcePoolMovedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmResourcePoolMovedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmResourcePoolMovedEvent_Def.schema - TClist = [GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"oldParent"), aname="_oldParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolEventArgument",lazy=True)(pname=(ns,"newParent"), aname="_newParent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.VmResourcePoolMovedEvent_Def.__bases__: - bases = list(ns0.VmResourcePoolMovedEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.VmResourcePoolMovedEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TemplateUpgradeEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TemplateUpgradeEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TemplateUpgradeEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"legacyTemplate"), aname="_legacyTemplate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.TemplateUpgradeEvent_Def.__bases__: - bases = list(ns0.TemplateUpgradeEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.TemplateUpgradeEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TemplateBeingUpgradedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TemplateBeingUpgradedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TemplateBeingUpgradedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TemplateUpgradeEvent_Def not in ns0.TemplateBeingUpgradedEvent_Def.__bases__: - bases = list(ns0.TemplateBeingUpgradedEvent_Def.__bases__) - bases.insert(0, ns0.TemplateUpgradeEvent_Def) - ns0.TemplateBeingUpgradedEvent_Def.__bases__ = tuple(bases) - - ns0.TemplateUpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TemplateUpgradeFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TemplateUpgradeFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TemplateUpgradeFailedEvent_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TemplateUpgradeEvent_Def not in ns0.TemplateUpgradeFailedEvent_Def.__bases__: - bases = list(ns0.TemplateUpgradeFailedEvent_Def.__bases__) - bases.insert(0, ns0.TemplateUpgradeEvent_Def) - ns0.TemplateUpgradeFailedEvent_Def.__bases__ = tuple(bases) - - ns0.TemplateUpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TemplateUpgradedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TemplateUpgradedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TemplateUpgradedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TemplateUpgradeEvent_Def not in ns0.TemplateUpgradedEvent_Def.__bases__: - bases = list(ns0.TemplateUpgradedEvent_Def.__bases__) - bases.insert(0, ns0.TemplateUpgradeEvent_Def) - ns0.TemplateUpgradedEvent_Def.__bases__ = tuple(bases) - - ns0.TemplateUpgradeEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"logLocation"), aname="_logLocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmEvent_Def not in ns0.CustomizationEvent_Def.__bases__: - bases = list(ns0.CustomizationEvent_Def.__bases__) - bases.insert(0, ns0.VmEvent_Def) - ns0.CustomizationEvent_Def.__bases__ = tuple(bases) - - ns0.VmEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationStartedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationStartedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationStartedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationEvent_Def not in ns0.CustomizationStartedEvent_Def.__bases__: - bases = list(ns0.CustomizationStartedEvent_Def.__bases__) - bases.insert(0, ns0.CustomizationEvent_Def) - ns0.CustomizationStartedEvent_Def.__bases__ = tuple(bases) - - ns0.CustomizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationSucceeded_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationSucceeded") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationSucceeded_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationEvent_Def not in ns0.CustomizationSucceeded_Def.__bases__: - bases = list(ns0.CustomizationSucceeded_Def.__bases__) - bases.insert(0, ns0.CustomizationEvent_Def) - ns0.CustomizationSucceeded_Def.__bases__ = tuple(bases) - - ns0.CustomizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationEvent_Def not in ns0.CustomizationFailed_Def.__bases__: - bases = list(ns0.CustomizationFailed_Def.__bases__) - bases.insert(0, ns0.CustomizationEvent_Def) - ns0.CustomizationFailed_Def.__bases__ = tuple(bases) - - ns0.CustomizationEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationUnknownFailure_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationUnknownFailure") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationUnknownFailure_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFailed_Def not in ns0.CustomizationUnknownFailure_Def.__bases__: - bases = list(ns0.CustomizationUnknownFailure_Def.__bases__) - bases.insert(0, ns0.CustomizationFailed_Def) - ns0.CustomizationUnknownFailure_Def.__bases__ = tuple(bases) - - ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationSysprepFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationSysprepFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationSysprepFailed_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"sysprepVersion"), aname="_sysprepVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemVersion"), aname="_systemVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFailed_Def not in ns0.CustomizationSysprepFailed_Def.__bases__: - bases = list(ns0.CustomizationSysprepFailed_Def.__bases__) - bases.insert(0, ns0.CustomizationFailed_Def) - ns0.CustomizationSysprepFailed_Def.__bases__ = tuple(bases) - - ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationLinuxIdentityFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationLinuxIdentityFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationLinuxIdentityFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFailed_Def not in ns0.CustomizationLinuxIdentityFailed_Def.__bases__: - bases = list(ns0.CustomizationLinuxIdentityFailed_Def.__bases__) - bases.insert(0, ns0.CustomizationFailed_Def) - ns0.CustomizationLinuxIdentityFailed_Def.__bases__ = tuple(bases) - - ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationNetworkSetupFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationNetworkSetupFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationNetworkSetupFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFailed_Def not in ns0.CustomizationNetworkSetupFailed_Def.__bases__: - bases = list(ns0.CustomizationNetworkSetupFailed_Def.__bases__) - bases.insert(0, ns0.CustomizationFailed_Def) - ns0.CustomizationNetworkSetupFailed_Def.__bases__ = tuple(bases) - - ns0.CustomizationFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LockerMisconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LockerMisconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LockerMisconfiguredEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.LockerMisconfiguredEvent_Def.__bases__: - bases = list(ns0.LockerMisconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.LockerMisconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LockerReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LockerReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LockerReconfiguredEvent_Def.schema - TClist = [GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"oldDatastore"), aname="_oldDatastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreEventArgument",lazy=True)(pname=(ns,"newDatastore"), aname="_newDatastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.LockerReconfiguredEvent_Def.__bases__: - bases = list(ns0.LockerReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.LockerReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoDatastoresConfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoDatastoresConfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoDatastoresConfiguredEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.NoDatastoresConfiguredEvent_Def.__bases__: - bases = list(ns0.NoDatastoresConfiguredEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.NoDatastoresConfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AdminPasswordNotChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AdminPasswordNotChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AdminPasswordNotChangedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.AdminPasswordNotChangedEvent_Def.__bases__: - bases = list(ns0.AdminPasswordNotChangedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.AdminPasswordNotChangedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VimAccountPasswordChangedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VimAccountPasswordChangedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VimAccountPasswordChangedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostEvent_Def not in ns0.VimAccountPasswordChangedEvent_Def.__bases__: - bases = list(ns0.VimAccountPasswordChangedEvent_Def.__bases__) - bases.insert(0, ns0.HostEvent_Def) - ns0.VimAccountPasswordChangedEvent_Def.__bases__ = tuple(bases) - - ns0.HostEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.DvsEvent_Def.__bases__: - bases = list(ns0.DvsEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.DvsEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsCreatedEvent_Def.schema - TClist = [GTD("urn:vim25","FolderEventArgument",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsCreatedEvent_Def.__bases__: - bases = list(ns0.DvsCreatedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsRenamedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsRenamedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsRenamedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsRenamedEvent_Def.__bases__: - bases = list(ns0.DvsRenamedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsRenamedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsReconfiguredEvent_Def.schema - TClist = [GTD("urn:vim25","DVSConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsReconfiguredEvent_Def.__bases__: - bases = list(ns0.DvsReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsUpgradeAvailableEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsUpgradeAvailableEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsUpgradeAvailableEvent_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsUpgradeAvailableEvent_Def.__bases__: - bases = list(ns0.DvsUpgradeAvailableEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsUpgradeAvailableEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsUpgradeInProgressEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsUpgradeInProgressEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsUpgradeInProgressEvent_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsUpgradeInProgressEvent_Def.__bases__: - bases = list(ns0.DvsUpgradeInProgressEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsUpgradeInProgressEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsUpgradeRejectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsUpgradeRejectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsUpgradeRejectedEvent_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsUpgradeRejectedEvent_Def.__bases__: - bases = list(ns0.DvsUpgradeRejectedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsUpgradeRejectedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsUpgradedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsUpgradedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsUpgradedEvent_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"productInfo"), aname="_productInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsUpgradedEvent_Def.__bases__: - bases = list(ns0.DvsUpgradedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsUpgradedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsHostJoinedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsHostJoinedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsHostJoinedEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"hostJoined"), aname="_hostJoined", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsHostJoinedEvent_Def.__bases__: - bases = list(ns0.DvsHostJoinedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsHostJoinedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsHostLeftEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsHostLeftEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsHostLeftEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"hostLeft"), aname="_hostLeft", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsHostLeftEvent_Def.__bases__: - bases = list(ns0.DvsHostLeftEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsHostLeftEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsOutOfSyncHostArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsOutOfSyncHostArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsOutOfSyncHostArgument_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"outOfSyncHost"), aname="_outOfSyncHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configParamters"), aname="_configParamters", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DvsOutOfSyncHostArgument_Def.__bases__: - bases = list(ns0.DvsOutOfSyncHostArgument_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DvsOutOfSyncHostArgument_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDvsOutOfSyncHostArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDvsOutOfSyncHostArgument") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDvsOutOfSyncHostArgument_Def.schema - TClist = [GTD("urn:vim25","DvsOutOfSyncHostArgument",lazy=True)(pname=(ns,"DvsOutOfSyncHostArgument"), aname="_DvsOutOfSyncHostArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DvsOutOfSyncHostArgument = [] - return - Holder.__name__ = "ArrayOfDvsOutOfSyncHostArgument_Holder" - self.pyclass = Holder - - class OutOfSyncDvsHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OutOfSyncDvsHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OutOfSyncDvsHost_Def.schema - TClist = [GTD("urn:vim25","DvsOutOfSyncHostArgument",lazy=True)(pname=(ns,"hostOutOfSync"), aname="_hostOutOfSync", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.OutOfSyncDvsHost_Def.__bases__: - bases = list(ns0.OutOfSyncDvsHost_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.OutOfSyncDvsHost_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsHostWentOutOfSyncEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsHostWentOutOfSyncEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsHostWentOutOfSyncEvent_Def.schema - TClist = [GTD("urn:vim25","DvsOutOfSyncHostArgument",lazy=True)(pname=(ns,"hostOutOfSync"), aname="_hostOutOfSync", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsHostWentOutOfSyncEvent_Def.__bases__: - bases = list(ns0.DvsHostWentOutOfSyncEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsHostWentOutOfSyncEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsHostBackInSyncEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsHostBackInSyncEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsHostBackInSyncEvent_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"hostBackInSync"), aname="_hostBackInSync", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsHostBackInSyncEvent_Def.__bases__: - bases = list(ns0.DvsHostBackInSyncEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsHostBackInSyncEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortCreatedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortCreatedEvent_Def.__bases__: - bases = list(ns0.DvsPortCreatedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortReconfiguredEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortReconfiguredEvent_Def.__bases__: - bases = list(ns0.DvsPortReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortDeletedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortDeletedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortDeletedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortDeletedEvent_Def.__bases__: - bases = list(ns0.DvsPortDeletedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortDeletedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortConnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortConnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortConnectedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnectee",lazy=True)(pname=(ns,"connectee"), aname="_connectee", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortConnectedEvent_Def.__bases__: - bases = list(ns0.DvsPortConnectedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortConnectedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortDisconnectedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortDisconnectedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortDisconnectedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnectee",lazy=True)(pname=(ns,"connectee"), aname="_connectee", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortDisconnectedEvent_Def.__bases__: - bases = list(ns0.DvsPortDisconnectedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortDisconnectedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortLinkUpEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortLinkUpEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortLinkUpEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortLinkUpEvent_Def.__bases__: - bases = list(ns0.DvsPortLinkUpEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortLinkUpEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortLinkDownEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortLinkDownEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortLinkDownEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortLinkDownEvent_Def.__bases__: - bases = list(ns0.DvsPortLinkDownEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortLinkDownEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortJoinPortgroupEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortJoinPortgroupEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortJoinPortgroupEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortJoinPortgroupEvent_Def.__bases__: - bases = list(ns0.DvsPortJoinPortgroupEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortJoinPortgroupEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortLeavePortgroupEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortLeavePortgroupEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortLeavePortgroupEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupKey"), aname="_portgroupKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroupName"), aname="_portgroupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortLeavePortgroupEvent_Def.__bases__: - bases = list(ns0.DvsPortLeavePortgroupEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortLeavePortgroupEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortBlockedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortBlockedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortBlockedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortBlockedEvent_Def.__bases__: - bases = list(ns0.DvsPortBlockedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortBlockedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsPortUnblockedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsPortUnblockedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsPortUnblockedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portKey"), aname="_portKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsPortUnblockedEvent_Def.__bases__: - bases = list(ns0.DvsPortUnblockedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsPortUnblockedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsDestroyedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsDestroyedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsDestroyedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsDestroyedEvent_Def.__bases__: - bases = list(ns0.DvsDestroyedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsDestroyedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsMergedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsMergedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsMergedEvent_Def.schema - TClist = [GTD("urn:vim25","DvsEventArgument",lazy=True)(pname=(ns,"sourceDvs"), aname="_sourceDvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsEventArgument",lazy=True)(pname=(ns,"destinationDvs"), aname="_destinationDvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsEvent_Def not in ns0.DvsMergedEvent_Def.__bases__: - bases = list(ns0.DvsMergedEvent_Def.__bases__) - bases.insert(0, ns0.DvsEvent_Def) - ns0.DvsMergedEvent_Def.__bases__ = tuple(bases) - - ns0.DvsEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortgroupEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Event_Def not in ns0.DVPortgroupEvent_Def.__bases__: - bases = list(ns0.DVPortgroupEvent_Def.__bases__) - bases.insert(0, ns0.Event_Def) - ns0.DVPortgroupEvent_Def.__bases__ = tuple(bases) - - ns0.Event_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortgroupCreatedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupCreatedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupCreatedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupCreatedEvent_Def.__bases__: - bases = list(ns0.DVPortgroupCreatedEvent_Def.__bases__) - bases.insert(0, ns0.DVPortgroupEvent_Def) - ns0.DVPortgroupCreatedEvent_Def.__bases__ = tuple(bases) - - ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortgroupRenamedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupRenamedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupRenamedEvent_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"oldName"), aname="_oldName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"newName"), aname="_newName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupRenamedEvent_Def.__bases__: - bases = list(ns0.DVPortgroupRenamedEvent_Def.__bases__) - bases.insert(0, ns0.DVPortgroupEvent_Def) - ns0.DVPortgroupRenamedEvent_Def.__bases__ = tuple(bases) - - ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortgroupReconfiguredEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupReconfiguredEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupReconfiguredEvent_Def.schema - TClist = [GTD("urn:vim25","DVPortgroupConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupReconfiguredEvent_Def.__bases__: - bases = list(ns0.DVPortgroupReconfiguredEvent_Def.__bases__) - bases.insert(0, ns0.DVPortgroupEvent_Def) - ns0.DVPortgroupReconfiguredEvent_Def.__bases__ = tuple(bases) - - ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DVPortgroupDestroyedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DVPortgroupDestroyedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DVPortgroupDestroyedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DVPortgroupEvent_Def not in ns0.DVPortgroupDestroyedEvent_Def.__bases__: - bases = list(ns0.DVPortgroupDestroyedEvent_Def.__bases__) - bases.insert(0, ns0.DVPortgroupEvent_Def) - ns0.DVPortgroupDestroyedEvent_Def.__bases__ = tuple(bases) - - ns0.DVPortgroupEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsInvocationFailedEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsInvocationFailedEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsInvocationFailedEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DrsInvocationFailedEvent_Def.__bases__: - bases = list(ns0.DrsInvocationFailedEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DrsInvocationFailedEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsRecoveredFromFailureEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsRecoveredFromFailureEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsRecoveredFromFailureEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterEvent_Def not in ns0.DrsRecoveredFromFailureEvent_Def.__bases__: - bases = list(ns0.DrsRecoveredFromFailureEvent_Def.__bases__) - bases.insert(0, ns0.ClusterEvent_Def) - ns0.DrsRecoveredFromFailureEvent_Def.__bases__ = tuple(bases) - - ns0.ClusterEvent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventArgument_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventArgument_Def.__bases__: - bases = list(ns0.EventArgument_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventArgument_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RoleEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RoleEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RoleEventArgument_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"roleId"), aname="_roleId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EventArgument_Def not in ns0.RoleEventArgument_Def.__bases__: - bases = list(ns0.RoleEventArgument_Def.__bases__) - bases.insert(0, ns0.EventArgument_Def) - ns0.RoleEventArgument_Def.__bases__ = tuple(bases) - - ns0.EventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EntityEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EntityEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EntityEventArgument_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EventArgument_Def not in ns0.EntityEventArgument_Def.__bases__: - bases = list(ns0.EntityEventArgument_Def.__bases__) - bases.insert(0, ns0.EventArgument_Def) - ns0.EntityEventArgument_Def.__bases__ = tuple(bases) - - ns0.EventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ManagedEntityEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ManagedEntityEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ManagedEntityEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.ManagedEntityEventArgument_Def.__bases__: - bases = list(ns0.ManagedEntityEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.ManagedEntityEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FolderEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FolderEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FolderEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"folder"), aname="_folder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.FolderEventArgument_Def.__bases__: - bases = list(ns0.FolderEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.FolderEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatacenterEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatacenterEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatacenterEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datacenter"), aname="_datacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.DatacenterEventArgument_Def.__bases__: - bases = list(ns0.DatacenterEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.DatacenterEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ComputeResourceEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComputeResourceEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComputeResourceEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"computeResource"), aname="_computeResource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.ComputeResourceEventArgument_Def.__bases__: - bases = list(ns0.ComputeResourceEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.ComputeResourceEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourcePoolEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourcePoolEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourcePoolEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.ResourcePoolEventArgument_Def.__bases__: - bases = list(ns0.ResourcePoolEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.ResourcePoolEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.HostEventArgument_Def.__bases__: - bases = list(ns0.HostEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.HostEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostEventArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostEventArgument") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostEventArgument_Def.schema - TClist = [GTD("urn:vim25","HostEventArgument",lazy=True)(pname=(ns,"HostEventArgument"), aname="_HostEventArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostEventArgument = [] - return - Holder.__name__ = "ArrayOfHostEventArgument_Holder" - self.pyclass = Holder - - class VmEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.VmEventArgument_Def.__bases__: - bases = list(ns0.VmEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.VmEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVmEventArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVmEventArgument") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVmEventArgument_Def.schema - TClist = [GTD("urn:vim25","VmEventArgument",lazy=True)(pname=(ns,"VmEventArgument"), aname="_VmEventArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VmEventArgument = [] - return - Holder.__name__ = "ArrayOfVmEventArgument_Holder" - self.pyclass = Holder - - class DatastoreEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.DatastoreEventArgument_Def.__bases__: - bases = list(ns0.DatastoreEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.DatastoreEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NetworkEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworkEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworkEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.NetworkEventArgument_Def.__bases__: - bases = list(ns0.NetworkEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.NetworkEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlarmEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlarmEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlarmEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.AlarmEventArgument_Def.__bases__: - bases = list(ns0.AlarmEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.AlarmEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.ScheduledTaskEventArgument_Def.__bases__: - bases = list(ns0.ScheduledTaskEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.ScheduledTaskEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EventArgument_Def not in ns0.ProfileEventArgument_Def.__bases__: - bases = list(ns0.ProfileEventArgument_Def.__bases__) - bases.insert(0, ns0.EventArgument_Def) - ns0.ProfileEventArgument_Def.__bases__ = tuple(bases) - - ns0.EventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsEventArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsEventArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsEventArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dvs"), aname="_dvs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EntityEventArgument_Def not in ns0.DvsEventArgument_Def.__bases__: - bases = list(ns0.DvsEventArgument_Def.__bases__) - bases.insert(0, ns0.EntityEventArgument_Def) - ns0.DvsEventArgument_Def.__bases__ = tuple(bases) - - ns0.EntityEventArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EventCategory_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EventCategory") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class EventArgDesc_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventArgDesc") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventArgDesc_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventArgDesc_Def.__bases__: - bases = list(ns0.EventArgDesc_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventArgDesc_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfEventArgDesc_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfEventArgDesc") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfEventArgDesc_Def.schema - TClist = [GTD("urn:vim25","EventArgDesc",lazy=True)(pname=(ns,"EventArgDesc"), aname="_EventArgDesc", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._EventArgDesc = [] - return - Holder.__name__ = "ArrayOfEventArgDesc_Holder" - self.pyclass = Holder - - class EventDescriptionEventDetail_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventDescriptionEventDetail") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventDescriptionEventDetail_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnDatacenter"), aname="_formatOnDatacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnComputeResource"), aname="_formatOnComputeResource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnHost"), aname="_formatOnHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"formatOnVm"), aname="_formatOnVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullFormat"), aname="_fullFormat", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventDescriptionEventDetail_Def.__bases__: - bases = list(ns0.EventDescriptionEventDetail_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventDescriptionEventDetail_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfEventDescriptionEventDetail_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfEventDescriptionEventDetail") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfEventDescriptionEventDetail_Def.schema - TClist = [GTD("urn:vim25","EventDescriptionEventDetail",lazy=True)(pname=(ns,"EventDescriptionEventDetail"), aname="_EventDescriptionEventDetail", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._EventDescriptionEventDetail = [] - return - Holder.__name__ = "ArrayOfEventDescriptionEventDetail_Holder" - self.pyclass = Holder - - class EventDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventDescription_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"category"), aname="_category", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventDescriptionEventDetail",lazy=True)(pname=(ns,"eventInfo"), aname="_eventInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EnumDescription",lazy=True)(pname=(ns,"enumeratedTypes"), aname="_enumeratedTypes", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventDescription_Def.__bases__: - bases = list(ns0.EventDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EventFilterSpecRecursionOption_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EventFilterSpecRecursionOption") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class EventFilterSpecByEntity_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventFilterSpecByEntity") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventFilterSpecByEntity_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpecRecursionOption",lazy=True)(pname=(ns,"recursion"), aname="_recursion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventFilterSpecByEntity_Def.__bases__: - bases = list(ns0.EventFilterSpecByEntity_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventFilterSpecByEntity_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EventFilterSpecByTime_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventFilterSpecByTime") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventFilterSpecByTime_Def.schema - TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"beginTime"), aname="_beginTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"endTime"), aname="_endTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventFilterSpecByTime_Def.__bases__: - bases = list(ns0.EventFilterSpecByTime_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventFilterSpecByTime_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EventFilterSpecByUsername_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventFilterSpecByUsername") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventFilterSpecByUsername_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"systemUser"), aname="_systemUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userList"), aname="_userList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventFilterSpecByUsername_Def.__bases__: - bases = list(ns0.EventFilterSpecByUsername_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventFilterSpecByUsername_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EventFilterSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EventFilterSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EventFilterSpec_Def.schema - TClist = [GTD("urn:vim25","EventFilterSpecByEntity",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpecByTime",lazy=True)(pname=(ns,"time"), aname="_time", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpecByUsername",lazy=True)(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"eventChainId"), aname="_eventChainId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"alarm"), aname="_alarm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"disableFullMessage"), aname="_disableFullMessage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"tag"), aname="_tag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.EventFilterSpec_Def.__bases__: - bases = list(ns0.EventFilterSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.EventFilterSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReadNextEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReadNextEventsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReadNextEventsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._maxCount = None - return - Holder.__name__ = "ReadNextEventsRequestType_Holder" - self.pyclass = Holder - - class ReadPreviousEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReadPreviousEventsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReadPreviousEventsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCount"), aname="_maxCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._maxCount = None - return - Holder.__name__ = "ReadPreviousEventsRequestType_Holder" - self.pyclass = Holder - - class RetrieveArgumentDescriptionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveArgumentDescriptionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveArgumentDescriptionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eventTypeId"), aname="_eventTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._eventTypeId = None - return - Holder.__name__ = "RetrieveArgumentDescriptionRequestType_Holder" - self.pyclass = Holder - - class CreateCollectorForEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateCollectorForEventsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateCollectorForEventsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpec",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._filter = None - return - Holder.__name__ = "CreateCollectorForEventsRequestType_Holder" - self.pyclass = Holder - - class LogUserEventRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LogUserEventRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.LogUserEventRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"msg"), aname="_msg", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._msg = None - return - Holder.__name__ = "LogUserEventRequestType_Holder" - self.pyclass = Holder - - class QueryEventsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryEventsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryEventsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","EventFilterSpec",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._filter = None - return - Holder.__name__ = "QueryEventsRequestType_Holder" - self.pyclass = Holder - - class PostEventRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PostEventRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.PostEventRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Event",lazy=True)(pname=(ns,"eventToPost"), aname="_eventToPost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"taskInfo"), aname="_taskInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._eventToPost = None - self._taskInfo = None - return - Holder.__name__ = "PostEventRequestType_Holder" - self.pyclass = Holder - - class AdminDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AdminDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AdminDisabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.AdminDisabled_Def.__bases__: - bases = list(ns0.AdminDisabled_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.AdminDisabled_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AdminNotDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AdminNotDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AdminNotDisabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.AdminNotDisabled_Def.__bases__: - bases = list(ns0.AdminNotDisabled_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.AdminNotDisabled_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AffinityType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AffinityType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class AffinityConfigured_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AffinityConfigured") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AffinityConfigured_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"configuredAffinity"), aname="_configuredAffinity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.AffinityConfigured_Def.__bases__: - bases = list(ns0.AffinityConfigured_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.AffinityConfigured_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AgentInstallFailedReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AgentInstallFailedReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class AgentInstallFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AgentInstallFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AgentInstallFailed_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"statusCode"), aname="_statusCode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installerOutput"), aname="_installerOutput", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.AgentInstallFailed_Def.__bases__: - bases = list(ns0.AgentInstallFailed_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.AgentInstallFailed_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlreadyBeingManaged_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlreadyBeingManaged") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlreadyBeingManaged_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.AlreadyBeingManaged_Def.__bases__: - bases = list(ns0.AlreadyBeingManaged_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.AlreadyBeingManaged_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlreadyConnected_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlreadyConnected") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlreadyConnected_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.AlreadyConnected_Def.__bases__: - bases = list(ns0.AlreadyConnected_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.AlreadyConnected_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlreadyExists_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlreadyExists") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlreadyExists_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.AlreadyExists_Def.__bases__: - bases = list(ns0.AlreadyExists_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.AlreadyExists_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AlreadyUpgraded_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AlreadyUpgraded") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AlreadyUpgraded_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.AlreadyUpgraded_Def.__bases__: - bases = list(ns0.AlreadyUpgraded_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.AlreadyUpgraded_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ApplicationQuiesceFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ApplicationQuiesceFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ApplicationQuiesceFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.ApplicationQuiesceFault_Def.__bases__: - bases = list(ns0.ApplicationQuiesceFault_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.ApplicationQuiesceFault_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AuthMinimumAdminPermission_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AuthMinimumAdminPermission") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AuthMinimumAdminPermission_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.AuthMinimumAdminPermission_Def.__bases__: - bases = list(ns0.AuthMinimumAdminPermission_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.AuthMinimumAdminPermission_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAccessFile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAccessFile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAccessFile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.CannotAccessFile_Def.__bases__: - bases = list(ns0.CannotAccessFile_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.CannotAccessFile_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAccessLocalSource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAccessLocalSource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAccessLocalSource_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.CannotAccessLocalSource_Def.__bases__: - bases = list(ns0.CannotAccessLocalSource_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.CannotAccessLocalSource_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAccessNetwork_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAccessNetwork") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAccessNetwork_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessVmDevice_Def not in ns0.CannotAccessNetwork_Def.__bases__: - bases = list(ns0.CannotAccessNetwork_Def.__bases__) - bases.insert(0, ns0.CannotAccessVmDevice_Def) - ns0.CannotAccessNetwork_Def.__bases__ = tuple(bases) - - ns0.CannotAccessVmDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAccessVmComponent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAccessVmComponent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAccessVmComponent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.CannotAccessVmComponent_Def.__bases__: - bases = list(ns0.CannotAccessVmComponent_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.CannotAccessVmComponent_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAccessVmConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAccessVmConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAccessVmConfig_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessVmComponent_Def not in ns0.CannotAccessVmConfig_Def.__bases__: - bases = list(ns0.CannotAccessVmConfig_Def.__bases__) - bases.insert(0, ns0.CannotAccessVmComponent_Def) - ns0.CannotAccessVmConfig_Def.__bases__ = tuple(bases) - - ns0.CannotAccessVmComponent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAccessVmDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAccessVmDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAccessVmDevice_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessVmComponent_Def not in ns0.CannotAccessVmDevice_Def.__bases__: - bases = list(ns0.CannotAccessVmDevice_Def.__bases__) - bases.insert(0, ns0.CannotAccessVmComponent_Def) - ns0.CannotAccessVmDevice_Def.__bases__ = tuple(bases) - - ns0.CannotAccessVmComponent_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAccessVmDisk_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAccessVmDisk") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAccessVmDisk_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessVmDevice_Def not in ns0.CannotAccessVmDisk_Def.__bases__: - bases = list(ns0.CannotAccessVmDisk_Def.__bases__) - bases.insert(0, ns0.CannotAccessVmDevice_Def) - ns0.CannotAccessVmDisk_Def.__bases__ = tuple(bases) - - ns0.CannotAccessVmDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAddHostWithFTVmAsStandalone_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAddHostWithFTVmAsStandalone") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAddHostWithFTVmAsStandalone_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.CannotAddHostWithFTVmAsStandalone_Def.__bases__: - bases = list(ns0.CannotAddHostWithFTVmAsStandalone_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.CannotAddHostWithFTVmAsStandalone_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAddHostWithFTVmToDifferentCluster_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAddHostWithFTVmToDifferentCluster") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAddHostWithFTVmToDifferentCluster_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__bases__: - bases = list(ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotAddHostWithFTVmToNonHACluster_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotAddHostWithFTVmToNonHACluster") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotAddHostWithFTVmToNonHACluster_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.CannotAddHostWithFTVmToNonHACluster_Def.__bases__: - bases = list(ns0.CannotAddHostWithFTVmToNonHACluster_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.CannotAddHostWithFTVmToNonHACluster_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotCreateFile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotCreateFile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotCreateFile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.CannotCreateFile_Def.__bases__: - bases = list(ns0.CannotCreateFile_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.CannotCreateFile_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotDecryptPasswords_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotDecryptPasswords") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotDecryptPasswords_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.CannotDecryptPasswords_Def.__bases__: - bases = list(ns0.CannotDecryptPasswords_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.CannotDecryptPasswords_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotDeleteFile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotDeleteFile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotDeleteFile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.CannotDeleteFile_Def.__bases__: - bases = list(ns0.CannotDeleteFile_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.CannotDeleteFile_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotDisableSnapshot_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotDisableSnapshot") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotDisableSnapshot_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.CannotDisableSnapshot_Def.__bases__: - bases = list(ns0.CannotDisableSnapshot_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.CannotDisableSnapshot_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotDisconnectHostWithFaultToleranceVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotDisconnectHostWithFaultToleranceVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotDisconnectHostWithFaultToleranceVm_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__bases__: - bases = list(ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotModifyConfigCpuRequirements_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotModifyConfigCpuRequirements") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotModifyConfigCpuRequirements_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.CannotModifyConfigCpuRequirements_Def.__bases__: - bases = list(ns0.CannotModifyConfigCpuRequirements_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.CannotModifyConfigCpuRequirements_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotMoveFaultToleranceVmMoveType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CannotMoveFaultToleranceVmMoveType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class CannotMoveFaultToleranceVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotMoveFaultToleranceVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotMoveFaultToleranceVm_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"moveType"), aname="_moveType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.CannotMoveFaultToleranceVm_Def.__bases__: - bases = list(ns0.CannotMoveFaultToleranceVm_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.CannotMoveFaultToleranceVm_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CannotMoveHostWithFaultToleranceVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CannotMoveHostWithFaultToleranceVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CannotMoveHostWithFaultToleranceVm_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.CannotMoveHostWithFaultToleranceVm_Def.__bases__: - bases = list(ns0.CannotMoveHostWithFaultToleranceVm_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.CannotMoveHostWithFaultToleranceVm_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CloneFromSnapshotNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CloneFromSnapshotNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CloneFromSnapshotNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.CloneFromSnapshotNotSupported_Def.__bases__: - bases = list(ns0.CloneFromSnapshotNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.CloneFromSnapshotNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ConcurrentAccess_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ConcurrentAccess") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ConcurrentAccess_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.ConcurrentAccess_Def.__bases__: - bases = list(ns0.ConcurrentAccess_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.ConcurrentAccess_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ConnectedIso_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ConnectedIso") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ConnectedIso_Def.schema - TClist = [GTD("urn:vim25","VirtualCdrom",lazy=True)(pname=(ns,"cdrom"), aname="_cdrom", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfExport_Def not in ns0.ConnectedIso_Def.__bases__: - bases = list(ns0.ConnectedIso_Def.__bases__) - bases.insert(0, ns0.OvfExport_Def) - ns0.ConnectedIso_Def.__bases__ = tuple(bases) - - ns0.OvfExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CpuCompatibilityUnknown_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CpuCompatibilityUnknown") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CpuCompatibilityUnknown_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CpuIncompatible_Def not in ns0.CpuCompatibilityUnknown_Def.__bases__: - bases = list(ns0.CpuCompatibilityUnknown_Def.__bases__) - bases.insert(0, ns0.CpuIncompatible_Def) - ns0.CpuCompatibilityUnknown_Def.__bases__ = tuple(bases) - - ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CpuHotPlugNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CpuHotPlugNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CpuHotPlugNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.CpuHotPlugNotSupported_Def.__bases__: - bases = list(ns0.CpuHotPlugNotSupported_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.CpuHotPlugNotSupported_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CpuIncompatible_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CpuIncompatible") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CpuIncompatible_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"registerName"), aname="_registerName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"registerBits"), aname="_registerBits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"desiredBits"), aname="_desiredBits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.CpuIncompatible_Def.__bases__: - bases = list(ns0.CpuIncompatible_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.CpuIncompatible_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CpuIncompatible1ECX_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CpuIncompatible1ECX") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CpuIncompatible1ECX_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"sse3"), aname="_sse3", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ssse3"), aname="_ssse3", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sse41"), aname="_sse41", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sse42"), aname="_sse42", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"other"), aname="_other", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"otherOnly"), aname="_otherOnly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CpuIncompatible_Def not in ns0.CpuIncompatible1ECX_Def.__bases__: - bases = list(ns0.CpuIncompatible1ECX_Def.__bases__) - bases.insert(0, ns0.CpuIncompatible_Def) - ns0.CpuIncompatible1ECX_Def.__bases__ = tuple(bases) - - ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CpuIncompatible81EDX_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CpuIncompatible81EDX") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CpuIncompatible81EDX_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"nx"), aname="_nx", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ffxsr"), aname="_ffxsr", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rdtscp"), aname="_rdtscp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"lm"), aname="_lm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"other"), aname="_other", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"otherOnly"), aname="_otherOnly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CpuIncompatible_Def not in ns0.CpuIncompatible81EDX_Def.__bases__: - bases = list(ns0.CpuIncompatible81EDX_Def.__bases__) - bases.insert(0, ns0.CpuIncompatible_Def) - ns0.CpuIncompatible81EDX_Def.__bases__ = tuple(bases) - - ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.CustomizationFault_Def.__bases__: - bases = list(ns0.CustomizationFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.CustomizationFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationPending_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationPending") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationPending_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.CustomizationPending_Def.__bases__: - bases = list(ns0.CustomizationPending_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.CustomizationPending_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DasConfigFaultDasConfigFaultReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DasConfigFaultDasConfigFaultReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DasConfigFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DasConfigFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DasConfigFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"output"), aname="_output", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Event",lazy=True)(pname=(ns,"event"), aname="_event", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.DasConfigFault_Def.__bases__: - bases = list(ns0.DasConfigFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.DasConfigFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatabaseError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatabaseError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatabaseError_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.DatabaseError_Def.__bases__: - bases = list(ns0.DatabaseError_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.DatabaseError_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatacenterMismatchArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatacenterMismatchArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatacenterMismatchArgument_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"inputDatacenter"), aname="_inputDatacenter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatacenterMismatchArgument_Def.__bases__: - bases = list(ns0.DatacenterMismatchArgument_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatacenterMismatchArgument_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDatacenterMismatchArgument_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDatacenterMismatchArgument") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDatacenterMismatchArgument_Def.schema - TClist = [GTD("urn:vim25","DatacenterMismatchArgument",lazy=True)(pname=(ns,"DatacenterMismatchArgument"), aname="_DatacenterMismatchArgument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DatacenterMismatchArgument = [] - return - Holder.__name__ = "ArrayOfDatacenterMismatchArgument_Holder" - self.pyclass = Holder - - class DatacenterMismatch_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatacenterMismatch") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatacenterMismatch_Def.schema - TClist = [GTD("urn:vim25","DatacenterMismatchArgument",lazy=True)(pname=(ns,"invalidArgument"), aname="_invalidArgument", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"expectedDatacenter"), aname="_expectedDatacenter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.DatacenterMismatch_Def.__bases__: - bases = list(ns0.DatacenterMismatch_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.DatacenterMismatch_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DatastoreNotWritableOnHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreNotWritableOnHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreNotWritableOnHost_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDatastore_Def not in ns0.DatastoreNotWritableOnHost_Def.__bases__: - bases = list(ns0.DatastoreNotWritableOnHost_Def.__bases__) - bases.insert(0, ns0.InvalidDatastore_Def) - ns0.DatastoreNotWritableOnHost_Def.__bases__ = tuple(bases) - - ns0.InvalidDatastore_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DestinationSwitchFull_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DestinationSwitchFull") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DestinationSwitchFull_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessNetwork_Def not in ns0.DestinationSwitchFull_Def.__bases__: - bases = list(ns0.DestinationSwitchFull_Def.__bases__) - bases.insert(0, ns0.CannotAccessNetwork_Def) - ns0.DestinationSwitchFull_Def.__bases__ = tuple(bases) - - ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceBackingNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceBackingNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceBackingNotSupported_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.DeviceBackingNotSupported_Def.__bases__: - bases = list(ns0.DeviceBackingNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.DeviceBackingNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceControllerNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceControllerNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceControllerNotSupported_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"controller"), aname="_controller", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.DeviceControllerNotSupported_Def.__bases__: - bases = list(ns0.DeviceControllerNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.DeviceControllerNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceHotPlugNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceHotPlugNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceHotPlugNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.DeviceHotPlugNotSupported_Def.__bases__: - bases = list(ns0.DeviceHotPlugNotSupported_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.DeviceHotPlugNotSupported_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceNotFound_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.DeviceNotFound_Def.__bases__: - bases = list(ns0.DeviceNotFound_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.DeviceNotFound_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceNotSupportedReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DeviceNotSupportedReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DeviceNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceNotSupported_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.DeviceNotSupported_Def.__bases__: - bases = list(ns0.DeviceNotSupported_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.DeviceNotSupported_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceUnsupportedForVmPlatform_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceUnsupportedForVmPlatform") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceUnsupportedForVmPlatform_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.DeviceUnsupportedForVmPlatform_Def.__bases__: - bases = list(ns0.DeviceUnsupportedForVmPlatform_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.DeviceUnsupportedForVmPlatform_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DeviceUnsupportedForVmVersion_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DeviceUnsupportedForVmVersion") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DeviceUnsupportedForVmVersion_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"currentVersion"), aname="_currentVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expectedVersion"), aname="_expectedVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.DeviceUnsupportedForVmVersion_Def.__bases__: - bases = list(ns0.DeviceUnsupportedForVmVersion_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.DeviceUnsupportedForVmVersion_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DisableAdminNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DisableAdminNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DisableAdminNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.DisableAdminNotSupported_Def.__bases__: - bases = list(ns0.DisableAdminNotSupported_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.DisableAdminNotSupported_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DisallowedDiskModeChange_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DisallowedDiskModeChange") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DisallowedDiskModeChange_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.DisallowedDiskModeChange_Def.__bases__: - bases = list(ns0.DisallowedDiskModeChange_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.DisallowedDiskModeChange_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DisallowedMigrationDeviceAttached_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DisallowedMigrationDeviceAttached") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DisallowedMigrationDeviceAttached_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.DisallowedMigrationDeviceAttached_Def.__bases__: - bases = list(ns0.DisallowedMigrationDeviceAttached_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.DisallowedMigrationDeviceAttached_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DisallowedOperationOnFailoverHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DisallowedOperationOnFailoverHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DisallowedOperationOnFailoverHost_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.DisallowedOperationOnFailoverHost_Def.__bases__: - bases = list(ns0.DisallowedOperationOnFailoverHost_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.DisallowedOperationOnFailoverHost_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DiskMoveTypeNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DiskMoveTypeNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DiskMoveTypeNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.DiskMoveTypeNotSupported_Def.__bases__: - bases = list(ns0.DiskMoveTypeNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.DiskMoveTypeNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DiskNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DiskNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DiskNotSupported_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"disk"), aname="_disk", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.DiskNotSupported_Def.__bases__: - bases = list(ns0.DiskNotSupported_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.DiskNotSupported_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsDisabledOnVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsDisabledOnVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsDisabledOnVm_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.DrsDisabledOnVm_Def.__bases__: - bases = list(ns0.DrsDisabledOnVm_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.DrsDisabledOnVm_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DrsVmotionIncompatibleFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DrsVmotionIncompatibleFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DrsVmotionIncompatibleFault_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.DrsVmotionIncompatibleFault_Def.__bases__: - bases = list(ns0.DrsVmotionIncompatibleFault_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.DrsVmotionIncompatibleFault_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DuplicateName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DuplicateName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DuplicateName_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"object"), aname="_object", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.DuplicateName_Def.__bases__: - bases = list(ns0.DuplicateName_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.DuplicateName_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.DvsFault_Def.__bases__: - bases = list(ns0.DvsFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.DvsFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsNotAuthorized_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsNotAuthorized") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsNotAuthorized_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"sessionExtensionKey"), aname="_sessionExtensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dvsExtensionKey"), aname="_dvsExtensionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsFault_Def not in ns0.DvsNotAuthorized_Def.__bases__: - bases = list(ns0.DvsNotAuthorized_Def.__bases__) - bases.insert(0, ns0.DvsFault_Def) - ns0.DvsNotAuthorized_Def.__bases__ = tuple(bases) - - ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsOperationBulkFaultFaultOnHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsOperationBulkFaultFaultOnHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsOperationBulkFaultFaultOnHost_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DvsOperationBulkFaultFaultOnHost_Def.__bases__: - bases = list(ns0.DvsOperationBulkFaultFaultOnHost_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DvsOperationBulkFaultFaultOnHost_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDvsOperationBulkFaultFaultOnHost_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDvsOperationBulkFaultFaultOnHost") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDvsOperationBulkFaultFaultOnHost_Def.schema - TClist = [GTD("urn:vim25","DvsOperationBulkFaultFaultOnHost",lazy=True)(pname=(ns,"DvsOperationBulkFaultFaultOnHost"), aname="_DvsOperationBulkFaultFaultOnHost", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DvsOperationBulkFaultFaultOnHost = [] - return - Holder.__name__ = "ArrayOfDvsOperationBulkFaultFaultOnHost_Holder" - self.pyclass = Holder - - class DvsOperationBulkFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsOperationBulkFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsOperationBulkFault_Def.schema - TClist = [GTD("urn:vim25","DvsOperationBulkFaultFaultOnHost",lazy=True)(pname=(ns,"hostFault"), aname="_hostFault", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsFault_Def not in ns0.DvsOperationBulkFault_Def.__bases__: - bases = list(ns0.DvsOperationBulkFault_Def.__bases__) - bases.insert(0, ns0.DvsFault_Def) - ns0.DvsOperationBulkFault_Def.__bases__ = tuple(bases) - - ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsScopeViolated_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsScopeViolated") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsScopeViolated_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scope"), aname="_scope", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsFault_Def not in ns0.DvsScopeViolated_Def.__bases__: - bases = list(ns0.DvsScopeViolated_Def.__bases__) - bases.insert(0, ns0.DvsFault_Def) - ns0.DvsScopeViolated_Def.__bases__ = tuple(bases) - - ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotSupportedHostInCluster_Def not in ns0.EVCAdmissionFailed_Def.__bases__: - bases = list(ns0.EVCAdmissionFailed_Def.__bases__) - bases.insert(0, ns0.NotSupportedHostInCluster_Def) - ns0.EVCAdmissionFailed_Def.__bases__ = tuple(bases) - - ns0.NotSupportedHostInCluster_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedCPUFeaturesForMode_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedCPUFeaturesForMode") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedCPUModel_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedCPUModel") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedCPUModel_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUModel_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUModel_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedCPUModel_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedCPUModelForMode_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedCPUModelForMode") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedCPUModelForMode_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUModelForMode_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUModelForMode_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedCPUModelForMode_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedCPUVendor_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedCPUVendor") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedCPUVendor_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"clusterCPUVendor"), aname="_clusterCPUVendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostCPUVendor"), aname="_hostCPUVendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUVendor_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUVendor_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedCPUVendor_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedCPUVendorUnknown_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedCPUVendorUnknown") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedCPUVendorUnknown_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedHostDisconnected_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedHostDisconnected") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedHostDisconnected_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedHostDisconnected_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedHostDisconnected_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedHostDisconnected_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedHostSoftware_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedHostSoftware") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedHostSoftware_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedHostSoftware_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedHostSoftware_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedHostSoftware_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedHostSoftwareForMode_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedHostSoftwareForMode") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedHostSoftwareForMode_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EVCAdmissionFailedVmActive_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EVCAdmissionFailedVmActive") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EVCAdmissionFailedVmActive_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedVmActive_Def.__bases__: - bases = list(ns0.EVCAdmissionFailedVmActive_Def.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedVmActive_Def.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EightHostLimitViolated_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "EightHostLimitViolated") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.EightHostLimitViolated_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.EightHostLimitViolated_Def.__bases__: - bases = list(ns0.EightHostLimitViolated_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.EightHostLimitViolated_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExpiredAddonLicense_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExpiredAddonLicense") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExpiredAddonLicense_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ExpiredFeatureLicense_Def not in ns0.ExpiredAddonLicense_Def.__bases__: - bases = list(ns0.ExpiredAddonLicense_Def.__bases__) - bases.insert(0, ns0.ExpiredFeatureLicense_Def) - ns0.ExpiredAddonLicense_Def.__bases__ = tuple(bases) - - ns0.ExpiredFeatureLicense_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExpiredEditionLicense_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExpiredEditionLicense") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExpiredEditionLicense_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ExpiredFeatureLicense_Def not in ns0.ExpiredEditionLicense_Def.__bases__: - bases = list(ns0.ExpiredEditionLicense_Def.__bases__) - bases.insert(0, ns0.ExpiredFeatureLicense_Def) - ns0.ExpiredEditionLicense_Def.__bases__ = tuple(bases) - - ns0.ExpiredFeatureLicense_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExpiredFeatureLicense_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExpiredFeatureLicense") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExpiredFeatureLicense_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"count"), aname="_count", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"expirationDate"), aname="_expirationDate", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.ExpiredFeatureLicense_Def.__bases__: - bases = list(ns0.ExpiredFeatureLicense_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.ExpiredFeatureLicense_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ExtendedFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ExtendedFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ExtendedFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"faultTypeId"), aname="_faultTypeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"data"), aname="_data", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.ExtendedFault_Def.__bases__: - bases = list(ns0.ExtendedFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.ExtendedFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultToleranceAntiAffinityViolated_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultToleranceAntiAffinityViolated") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultToleranceAntiAffinityViolated_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.FaultToleranceAntiAffinityViolated_Def.__bases__: - bases = list(ns0.FaultToleranceAntiAffinityViolated_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.FaultToleranceAntiAffinityViolated_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultToleranceCpuIncompatible_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultToleranceCpuIncompatible") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultToleranceCpuIncompatible_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"family"), aname="_family", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"stepping"), aname="_stepping", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CpuIncompatible_Def not in ns0.FaultToleranceCpuIncompatible_Def.__bases__: - bases = list(ns0.FaultToleranceCpuIncompatible_Def.__bases__) - bases.insert(0, ns0.CpuIncompatible_Def) - ns0.FaultToleranceCpuIncompatible_Def.__bases__ = tuple(bases) - - ns0.CpuIncompatible_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultToleranceNotLicensed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultToleranceNotLicensed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultToleranceNotLicensed_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.FaultToleranceNotLicensed_Def.__bases__: - bases = list(ns0.FaultToleranceNotLicensed_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.FaultToleranceNotLicensed_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultToleranceNotSameBuild_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultToleranceNotSameBuild") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultToleranceNotSameBuild_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"build"), aname="_build", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.FaultToleranceNotSameBuild_Def.__bases__: - bases = list(ns0.FaultToleranceNotSameBuild_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.FaultToleranceNotSameBuild_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultTolerancePrimaryPowerOnNotAttempted_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultTolerancePrimaryPowerOnNotAttempted") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"secondaryVm"), aname="_secondaryVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"primaryVm"), aname="_primaryVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__bases__: - bases = list(ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileAlreadyExists_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileAlreadyExists") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileAlreadyExists_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.FileAlreadyExists_Def.__bases__: - bases = list(ns0.FileAlreadyExists_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.FileAlreadyExists_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileBackedPortNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileBackedPortNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileBackedPortNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.FileBackedPortNotSupported_Def.__bases__: - bases = list(ns0.FileBackedPortNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.FileBackedPortNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"file"), aname="_file", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.FileFault_Def.__bases__: - bases = list(ns0.FileFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.FileFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileLocked_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileLocked") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileLocked_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.FileLocked_Def.__bases__: - bases = list(ns0.FileLocked_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.FileLocked_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileNotFound_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.FileNotFound_Def.__bases__: - bases = list(ns0.FileNotFound_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.FileNotFound_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileNotWritable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileNotWritable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileNotWritable_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.FileNotWritable_Def.__bases__: - bases = list(ns0.FileNotWritable_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.FileNotWritable_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileTooLarge_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileTooLarge") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileTooLarge_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"fileSize"), aname="_fileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxFileSize"), aname="_maxFileSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.FileTooLarge_Def.__bases__: - bases = list(ns0.FileTooLarge_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.FileTooLarge_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FilesystemQuiesceFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FilesystemQuiesceFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FilesystemQuiesceFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.FilesystemQuiesceFault_Def.__bases__: - bases = list(ns0.FilesystemQuiesceFault_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.FilesystemQuiesceFault_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FtIssuesOnHostHostSelectionType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FtIssuesOnHostHostSelectionType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class FtIssuesOnHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FtIssuesOnHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FtIssuesOnHost_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"errors"), aname="_errors", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.FtIssuesOnHost_Def.__bases__: - bases = list(ns0.FtIssuesOnHost_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.FtIssuesOnHost_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FullStorageVMotionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FullStorageVMotionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FullStorageVMotionNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFeatureNotSupported_Def not in ns0.FullStorageVMotionNotSupported_Def.__bases__: - bases = list(ns0.FullStorageVMotionNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFeatureNotSupported_Def) - ns0.FullStorageVMotionNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GenericDrsFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GenericDrsFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GenericDrsFault_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"hostFaults"), aname="_hostFaults", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.GenericDrsFault_Def.__bases__: - bases = list(ns0.GenericDrsFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.GenericDrsFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class GenericVmConfigFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GenericVmConfigFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GenericVmConfigFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.GenericVmConfigFault_Def.__bases__: - bases = list(ns0.GenericVmConfigFault_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.GenericVmConfigFault_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HAErrorsAtDest_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HAErrorsAtDest") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HAErrorsAtDest_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.HAErrorsAtDest_Def.__bases__: - bases = list(ns0.HAErrorsAtDest_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.HAErrorsAtDest_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigFailed_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"failure"), aname="_failure", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.HostConfigFailed_Def.__bases__: - bases = list(ns0.HostConfigFailed_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.HostConfigFailed_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.HostConfigFault_Def.__bases__: - bases = list(ns0.HostConfigFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.HostConfigFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConnectFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConnectFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConnectFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.HostConnectFault_Def.__bases__: - bases = list(ns0.HostConnectFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.HostConnectFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIncompatibleForFaultToleranceReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostIncompatibleForFaultToleranceReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostIncompatibleForFaultTolerance_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIncompatibleForFaultTolerance") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIncompatibleForFaultTolerance_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.HostIncompatibleForFaultTolerance_Def.__bases__: - bases = list(ns0.HostIncompatibleForFaultTolerance_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.HostIncompatibleForFaultTolerance_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIncompatibleForRecordReplayReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostIncompatibleForRecordReplayReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostIncompatibleForRecordReplay_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIncompatibleForRecordReplay") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIncompatibleForRecordReplay_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.HostIncompatibleForRecordReplay_Def.__bases__: - bases = list(ns0.HostIncompatibleForRecordReplay_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.HostIncompatibleForRecordReplay_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInventoryFull_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInventoryFull") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInventoryFull_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.HostInventoryFull_Def.__bases__: - bases = list(ns0.HostInventoryFull_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.HostInventoryFull_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostPowerOpFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPowerOpFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPowerOpFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.HostPowerOpFailed_Def.__bases__: - bases = list(ns0.HostPowerOpFailed_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.HostPowerOpFailed_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HotSnapshotMoveNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HotSnapshotMoveNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HotSnapshotMoveNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotCopyNotSupported_Def not in ns0.HotSnapshotMoveNotSupported_Def.__bases__: - bases = list(ns0.HotSnapshotMoveNotSupported_Def.__bases__) - bases.insert(0, ns0.SnapshotCopyNotSupported_Def) - ns0.HotSnapshotMoveNotSupported_Def.__bases__ = tuple(bases) - - ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IDEDiskNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IDEDiskNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IDEDiskNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DiskNotSupported_Def not in ns0.IDEDiskNotSupported_Def.__bases__: - bases = list(ns0.IDEDiskNotSupported_Def.__bases__) - bases.insert(0, ns0.DiskNotSupported_Def) - ns0.IDEDiskNotSupported_Def.__bases__ = tuple(bases) - - ns0.DiskNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InUseFeatureManipulationDisallowed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InUseFeatureManipulationDisallowed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InUseFeatureManipulationDisallowed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.InUseFeatureManipulationDisallowed_Def.__bases__: - bases = list(ns0.InUseFeatureManipulationDisallowed_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.InUseFeatureManipulationDisallowed_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InaccessibleDatastore_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InaccessibleDatastore") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InaccessibleDatastore_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDatastore_Def not in ns0.InaccessibleDatastore_Def.__bases__: - bases = list(ns0.InaccessibleDatastore_Def.__bases__) - bases.insert(0, ns0.InvalidDatastore_Def) - ns0.InaccessibleDatastore_Def.__bases__ = tuple(bases) - - ns0.InvalidDatastore_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IncompatibleDefaultDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IncompatibleDefaultDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IncompatibleDefaultDevice_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.IncompatibleDefaultDevice_Def.__bases__: - bases = list(ns0.IncompatibleDefaultDevice_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.IncompatibleDefaultDevice_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IncompatibleHostForFtSecondary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IncompatibleHostForFtSecondary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IncompatibleHostForFtSecondary_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.IncompatibleHostForFtSecondary_Def.__bases__: - bases = list(ns0.IncompatibleHostForFtSecondary_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.IncompatibleHostForFtSecondary_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IncompatibleSetting_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IncompatibleSetting") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IncompatibleSetting_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"conflictingProperty"), aname="_conflictingProperty", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidArgument_Def not in ns0.IncompatibleSetting_Def.__bases__: - bases = list(ns0.IncompatibleSetting_Def.__bases__) - bases.insert(0, ns0.InvalidArgument_Def) - ns0.IncompatibleSetting_Def.__bases__ = tuple(bases) - - ns0.InvalidArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IncorrectFileType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IncorrectFileType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IncorrectFileType_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.IncorrectFileType_Def.__bases__: - bases = list(ns0.IncorrectFileType_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.IncorrectFileType_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IncorrectHostInformation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IncorrectHostInformation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IncorrectHostInformation_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.IncorrectHostInformation_Def.__bases__: - bases = list(ns0.IncorrectHostInformation_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.IncorrectHostInformation_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IndependentDiskVMotionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IndependentDiskVMotionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IndependentDiskVMotionNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFeatureNotSupported_Def not in ns0.IndependentDiskVMotionNotSupported_Def.__bases__: - bases = list(ns0.IndependentDiskVMotionNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFeatureNotSupported_Def) - ns0.IndependentDiskVMotionNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientCpuResourcesFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientCpuResourcesFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientCpuResourcesFault_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientCpuResourcesFault_Def.__bases__: - bases = list(ns0.InsufficientCpuResourcesFault_Def.__bases__) - bases.insert(0, ns0.InsufficientResourcesFault_Def) - ns0.InsufficientCpuResourcesFault_Def.__bases__ = tuple(bases) - - ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientFailoverResourcesFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientFailoverResourcesFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientFailoverResourcesFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientFailoverResourcesFault_Def.__bases__: - bases = list(ns0.InsufficientFailoverResourcesFault_Def.__bases__) - bases.insert(0, ns0.InsufficientResourcesFault_Def) - ns0.InsufficientFailoverResourcesFault_Def.__bases__ = tuple(bases) - - ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientHostCapacityFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientHostCapacityFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientHostCapacityFault_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientHostCapacityFault_Def.__bases__: - bases = list(ns0.InsufficientHostCapacityFault_Def.__bases__) - bases.insert(0, ns0.InsufficientResourcesFault_Def) - ns0.InsufficientHostCapacityFault_Def.__bases__ = tuple(bases) - - ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientHostCpuCapacityFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientHostCpuCapacityFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientHostCpuCapacityFault_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientHostCpuCapacityFault_Def.__bases__: - bases = list(ns0.InsufficientHostCpuCapacityFault_Def.__bases__) - bases.insert(0, ns0.InsufficientHostCapacityFault_Def) - ns0.InsufficientHostCpuCapacityFault_Def.__bases__ = tuple(bases) - - ns0.InsufficientHostCapacityFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientHostMemoryCapacityFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientHostMemoryCapacityFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientHostMemoryCapacityFault_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientHostMemoryCapacityFault_Def.__bases__: - bases = list(ns0.InsufficientHostMemoryCapacityFault_Def.__bases__) - bases.insert(0, ns0.InsufficientHostCapacityFault_Def) - ns0.InsufficientHostMemoryCapacityFault_Def.__bases__ = tuple(bases) - - ns0.InsufficientHostCapacityFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientMemoryResourcesFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientMemoryResourcesFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientMemoryResourcesFault_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientMemoryResourcesFault_Def.__bases__: - bases = list(ns0.InsufficientMemoryResourcesFault_Def.__bases__) - bases.insert(0, ns0.InsufficientResourcesFault_Def) - ns0.InsufficientMemoryResourcesFault_Def.__bases__ = tuple(bases) - - ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientPerCpuCapacity_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientPerCpuCapacity") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientPerCpuCapacity_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientPerCpuCapacity_Def.__bases__: - bases = list(ns0.InsufficientPerCpuCapacity_Def.__bases__) - bases.insert(0, ns0.InsufficientHostCapacityFault_Def) - ns0.InsufficientPerCpuCapacity_Def.__bases__ = tuple(bases) - - ns0.InsufficientHostCapacityFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientResourcesFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientResourcesFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientResourcesFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InsufficientResourcesFault_Def.__bases__: - bases = list(ns0.InsufficientResourcesFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InsufficientResourcesFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientStandbyCpuResource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientStandbyCpuResource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientStandbyCpuResource_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientStandbyResource_Def not in ns0.InsufficientStandbyCpuResource_Def.__bases__: - bases = list(ns0.InsufficientStandbyCpuResource_Def.__bases__) - bases.insert(0, ns0.InsufficientStandbyResource_Def) - ns0.InsufficientStandbyCpuResource_Def.__bases__ = tuple(bases) - - ns0.InsufficientStandbyResource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientStandbyMemoryResource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientStandbyMemoryResource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientStandbyMemoryResource_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"requested"), aname="_requested", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientStandbyResource_Def not in ns0.InsufficientStandbyMemoryResource_Def.__bases__: - bases = list(ns0.InsufficientStandbyMemoryResource_Def.__bases__) - bases.insert(0, ns0.InsufficientStandbyResource_Def) - ns0.InsufficientStandbyMemoryResource_Def.__bases__ = tuple(bases) - - ns0.InsufficientStandbyResource_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InsufficientStandbyResource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InsufficientStandbyResource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InsufficientStandbyResource_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientStandbyResource_Def.__bases__: - bases = list(ns0.InsufficientStandbyResource_Def.__bases__) - bases.insert(0, ns0.InsufficientResourcesFault_Def) - ns0.InsufficientStandbyResource_Def.__bases__ = tuple(bases) - - ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidAffinitySettingFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidAffinitySettingFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidAffinitySettingFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidAffinitySettingFault_Def.__bases__: - bases = list(ns0.InvalidAffinitySettingFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidAffinitySettingFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidBmcRole_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidBmcRole") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidBmcRole_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidBmcRole_Def.__bases__: - bases = list(ns0.InvalidBmcRole_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidBmcRole_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidBundle_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidBundle") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidBundle_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PlatformConfigFault_Def not in ns0.InvalidBundle_Def.__bases__: - bases = list(ns0.InvalidBundle_Def.__bases__) - bases.insert(0, ns0.PlatformConfigFault_Def) - ns0.InvalidBundle_Def.__bases__ = tuple(bases) - - ns0.PlatformConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidClientCertificate_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidClientCertificate") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidClientCertificate_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidLogin_Def not in ns0.InvalidClientCertificate_Def.__bases__: - bases = list(ns0.InvalidClientCertificate_Def.__bases__) - bases.insert(0, ns0.InvalidLogin_Def) - ns0.InvalidClientCertificate_Def.__bases__ = tuple(bases) - - ns0.InvalidLogin_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidController_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"controllerKey"), aname="_controllerKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.InvalidController_Def.__bases__: - bases = list(ns0.InvalidController_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.InvalidController_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidDatastore_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidDatastore") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidDatastore_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidDatastore_Def.__bases__: - bases = list(ns0.InvalidDatastore_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidDatastore_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidDatastorePath_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidDatastorePath") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidDatastorePath_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDatastore_Def not in ns0.InvalidDatastorePath_Def.__bases__: - bases = list(ns0.InvalidDatastorePath_Def.__bases__) - bases.insert(0, ns0.InvalidDatastore_Def) - ns0.InvalidDatastorePath_Def.__bases__ = tuple(bases) - - ns0.InvalidDatastore_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidDeviceBacking_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidDeviceBacking") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidDeviceBacking_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.InvalidDeviceBacking_Def.__bases__: - bases = list(ns0.InvalidDeviceBacking_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.InvalidDeviceBacking_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidDeviceOperation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidDeviceOperation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidDeviceOperation_Def.schema - TClist = [GTD("urn:vim25","VirtualDeviceConfigSpecOperation",lazy=True)(pname=(ns,"badOp"), aname="_badOp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConfigSpecFileOperation",lazy=True)(pname=(ns,"badFileOp"), aname="_badFileOp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.InvalidDeviceOperation_Def.__bases__: - bases = list(ns0.InvalidDeviceOperation_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.InvalidDeviceOperation_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidDeviceSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidDeviceSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidDeviceSpec_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"deviceIndex"), aname="_deviceIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidVmConfig_Def not in ns0.InvalidDeviceSpec_Def.__bases__: - bases = list(ns0.InvalidDeviceSpec_Def.__bases__) - bases.insert(0, ns0.InvalidVmConfig_Def) - ns0.InvalidDeviceSpec_Def.__bases__ = tuple(bases) - - ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidDiskFormat_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidDiskFormat") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidDiskFormat_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidFormat_Def not in ns0.InvalidDiskFormat_Def.__bases__: - bases = list(ns0.InvalidDiskFormat_Def.__bases__) - bases.insert(0, ns0.InvalidFormat_Def) - ns0.InvalidDiskFormat_Def.__bases__ = tuple(bases) - - ns0.InvalidFormat_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidDrsBehaviorForFtVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidDrsBehaviorForFtVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidDrsBehaviorForFtVm_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidArgument_Def not in ns0.InvalidDrsBehaviorForFtVm_Def.__bases__: - bases = list(ns0.InvalidDrsBehaviorForFtVm_Def.__bases__) - bases.insert(0, ns0.InvalidArgument_Def) - ns0.InvalidDrsBehaviorForFtVm_Def.__bases__ = tuple(bases) - - ns0.InvalidArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidEditionLicense_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidEditionLicense") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidEditionLicense_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"feature"), aname="_feature", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.InvalidEditionLicense_Def.__bases__: - bases = list(ns0.InvalidEditionLicense_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.InvalidEditionLicense_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidEvent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidEvent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidEvent_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidEvent_Def.__bases__: - bases = list(ns0.InvalidEvent_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidEvent_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidFolder_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidFolder") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidFolder_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidFolder_Def.__bases__: - bases = list(ns0.InvalidFolder_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidFolder_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidFormat_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidFormat") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidFormat_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.InvalidFormat_Def.__bases__: - bases = list(ns0.InvalidFormat_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.InvalidFormat_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidHostState_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidHostState") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidHostState_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidState_Def not in ns0.InvalidHostState_Def.__bases__: - bases = list(ns0.InvalidHostState_Def.__bases__) - bases.insert(0, ns0.InvalidState_Def) - ns0.InvalidHostState_Def.__bases__ = tuple(bases) - - ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidIndexArgument_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidIndexArgument") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidIndexArgument_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidArgument_Def not in ns0.InvalidIndexArgument_Def.__bases__: - bases = list(ns0.InvalidIndexArgument_Def.__bases__) - bases.insert(0, ns0.InvalidArgument_Def) - ns0.InvalidIndexArgument_Def.__bases__ = tuple(bases) - - ns0.InvalidArgument_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidIpmiLoginInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidIpmiLoginInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidIpmiLoginInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidIpmiLoginInfo_Def.__bases__: - bases = list(ns0.InvalidIpmiLoginInfo_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidIpmiLoginInfo_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidIpmiMacAddress_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidIpmiMacAddress") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidIpmiMacAddress_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userProvidedMacAddress"), aname="_userProvidedMacAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"observedMacAddress"), aname="_observedMacAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidIpmiMacAddress_Def.__bases__: - bases = list(ns0.InvalidIpmiMacAddress_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidIpmiMacAddress_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidLicense_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidLicense") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidLicense_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseContent"), aname="_licenseContent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidLicense_Def.__bases__: - bases = list(ns0.InvalidLicense_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidLicense_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidLocale_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidLocale") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidLocale_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidLocale_Def.__bases__: - bases = list(ns0.InvalidLocale_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidLocale_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidLogin_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidLogin") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidLogin_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidLogin_Def.__bases__: - bases = list(ns0.InvalidLogin_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidLogin_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidName_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidName_Def.__bases__: - bases = list(ns0.InvalidName_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidName_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidNasCredentials_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidNasCredentials") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidNasCredentials_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NasConfigFault_Def not in ns0.InvalidNasCredentials_Def.__bases__: - bases = list(ns0.InvalidNasCredentials_Def.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.InvalidNasCredentials_Def.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidNetworkInType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidNetworkInType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidNetworkInType_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppPropertyFault_Def not in ns0.InvalidNetworkInType_Def.__bases__: - bases = list(ns0.InvalidNetworkInType_Def.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.InvalidNetworkInType_Def.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidNetworkResource_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidNetworkResource") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidNetworkResource_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NasConfigFault_Def not in ns0.InvalidNetworkResource_Def.__bases__: - bases = list(ns0.InvalidNetworkResource_Def.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.InvalidNetworkResource_Def.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidOperationOnSecondaryVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidOperationOnSecondaryVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidOperationOnSecondaryVm_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.InvalidOperationOnSecondaryVm_Def.__bases__: - bases = list(ns0.InvalidOperationOnSecondaryVm_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.InvalidOperationOnSecondaryVm_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidPowerState_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidPowerState") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidPowerState_Def.schema - TClist = [GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"requestedState"), aname="_requestedState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"existingState"), aname="_existingState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidState_Def not in ns0.InvalidPowerState_Def.__bases__: - bases = list(ns0.InvalidPowerState_Def.__bases__) - bases.insert(0, ns0.InvalidState_Def) - ns0.InvalidPowerState_Def.__bases__ = tuple(bases) - - ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidPrivilege_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidPrivilege") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidPrivilege_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"privilege"), aname="_privilege", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidPrivilege_Def.__bases__: - bases = list(ns0.InvalidPrivilege_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidPrivilege_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidPropertyType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidPropertyType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidPropertyType_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppPropertyFault_Def not in ns0.InvalidPropertyType_Def.__bases__: - bases = list(ns0.InvalidPropertyType_Def.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.InvalidPropertyType_Def.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidPropertyValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidPropertyValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidPropertyValue_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppPropertyFault_Def not in ns0.InvalidPropertyValue_Def.__bases__: - bases = list(ns0.InvalidPropertyValue_Def.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.InvalidPropertyValue_Def.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidResourcePoolStructureFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidResourcePoolStructureFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidResourcePoolStructureFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InsufficientResourcesFault_Def not in ns0.InvalidResourcePoolStructureFault_Def.__bases__: - bases = list(ns0.InvalidResourcePoolStructureFault_Def.__bases__) - bases.insert(0, ns0.InsufficientResourcesFault_Def) - ns0.InvalidResourcePoolStructureFault_Def.__bases__ = tuple(bases) - - ns0.InsufficientResourcesFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidSnapshotFormat_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidSnapshotFormat") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidSnapshotFormat_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidFormat_Def not in ns0.InvalidSnapshotFormat_Def.__bases__: - bases = list(ns0.InvalidSnapshotFormat_Def.__bases__) - bases.insert(0, ns0.InvalidFormat_Def) - ns0.InvalidSnapshotFormat_Def.__bases__ = tuple(bases) - - ns0.InvalidFormat_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidState_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidState") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidState_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.InvalidState_Def.__bases__: - bases = list(ns0.InvalidState_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.InvalidState_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InvalidVmConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InvalidVmConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InvalidVmConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.InvalidVmConfig_Def.__bases__: - bases = list(ns0.InvalidVmConfig_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.InvalidVmConfig_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InventoryHasStandardAloneHosts_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "InventoryHasStandardAloneHosts") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.InventoryHasStandardAloneHosts_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hosts"), aname="_hosts", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.InventoryHasStandardAloneHosts_Def.__bases__: - bases = list(ns0.InventoryHasStandardAloneHosts_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.InventoryHasStandardAloneHosts_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IpHostnameGeneratorError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IpHostnameGeneratorError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IpHostnameGeneratorError_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.IpHostnameGeneratorError_Def.__bases__: - bases = list(ns0.IpHostnameGeneratorError_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.IpHostnameGeneratorError_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LegacyNetworkInterfaceInUse_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LegacyNetworkInterfaceInUse") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LegacyNetworkInterfaceInUse_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessNetwork_Def not in ns0.LegacyNetworkInterfaceInUse_Def.__bases__: - bases = list(ns0.LegacyNetworkInterfaceInUse_Def.__bases__) - bases.insert(0, ns0.CannotAccessNetwork_Def) - ns0.LegacyNetworkInterfaceInUse_Def.__bases__ = tuple(bases) - - ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseAssignmentFailedReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LicenseAssignmentFailedReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LicenseAssignmentFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseAssignmentFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseAssignmentFailed_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.LicenseAssignmentFailed_Def.__bases__: - bases = list(ns0.LicenseAssignmentFailed_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.LicenseAssignmentFailed_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseDowngradeDisallowed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseDowngradeDisallowed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseDowngradeDisallowed_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"edition"), aname="_edition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityId"), aname="_entityId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"features"), aname="_features", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.LicenseDowngradeDisallowed_Def.__bases__: - bases = list(ns0.LicenseDowngradeDisallowed_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.LicenseDowngradeDisallowed_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseExpired_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseExpired") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseExpired_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseKey"), aname="_licenseKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.LicenseExpired_Def.__bases__: - bases = list(ns0.LicenseExpired_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.LicenseExpired_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseKeyEntityMismatch_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseKeyEntityMismatch") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseKeyEntityMismatch_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.LicenseKeyEntityMismatch_Def.__bases__: - bases = list(ns0.LicenseKeyEntityMismatch_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.LicenseKeyEntityMismatch_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseRestricted_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseRestricted") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseRestricted_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.LicenseRestricted_Def.__bases__: - bases = list(ns0.LicenseRestricted_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.LicenseRestricted_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseServerUnavailable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseServerUnavailable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseServerUnavailable_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"licenseServer"), aname="_licenseServer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.LicenseServerUnavailable_Def.__bases__: - bases = list(ns0.LicenseServerUnavailable_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.LicenseServerUnavailable_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LicenseSourceUnavailable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LicenseSourceUnavailable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LicenseSourceUnavailable_Def.schema - TClist = [GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"licenseSource"), aname="_licenseSource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.LicenseSourceUnavailable_Def.__bases__: - bases = list(ns0.LicenseSourceUnavailable_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.LicenseSourceUnavailable_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LimitExceeded_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LimitExceeded") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LimitExceeded_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"limit"), aname="_limit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.LimitExceeded_Def.__bases__: - bases = list(ns0.LimitExceeded_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.LimitExceeded_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LinuxVolumeNotClean_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LinuxVolumeNotClean") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LinuxVolumeNotClean_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.LinuxVolumeNotClean_Def.__bases__: - bases = list(ns0.LinuxVolumeNotClean_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.LinuxVolumeNotClean_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LogBundlingFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LogBundlingFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LogBundlingFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.LogBundlingFailed_Def.__bases__: - bases = list(ns0.LogBundlingFailed_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.LogBundlingFailed_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MaintenanceModeFileMove_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MaintenanceModeFileMove") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MaintenanceModeFileMove_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.MaintenanceModeFileMove_Def.__bases__: - bases = list(ns0.MaintenanceModeFileMove_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.MaintenanceModeFileMove_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MemoryHotPlugNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MemoryHotPlugNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MemoryHotPlugNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.MemoryHotPlugNotSupported_Def.__bases__: - bases = list(ns0.MemoryHotPlugNotSupported_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.MemoryHotPlugNotSupported_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MemorySizeNotRecommended_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MemorySizeNotRecommended") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MemorySizeNotRecommended_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"memorySizeMB"), aname="_memorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"minMemorySizeMB"), aname="_minMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemorySizeMB"), aname="_maxMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.MemorySizeNotRecommended_Def.__bases__: - bases = list(ns0.MemorySizeNotRecommended_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.MemorySizeNotRecommended_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MemorySizeNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MemorySizeNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MemorySizeNotSupported_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"memorySizeMB"), aname="_memorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"minMemorySizeMB"), aname="_minMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemorySizeMB"), aname="_maxMemorySizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.MemorySizeNotSupported_Def.__bases__: - bases = list(ns0.MemorySizeNotSupported_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.MemorySizeNotSupported_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MemorySnapshotOnIndependentDisk_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MemorySnapshotOnIndependentDisk") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MemorySnapshotOnIndependentDisk_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.MemorySnapshotOnIndependentDisk_Def.__bases__: - bases = list(ns0.MemorySnapshotOnIndependentDisk_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.MemorySnapshotOnIndependentDisk_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MethodDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MethodDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MethodDisabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RuntimeFault_Def not in ns0.MethodDisabled_Def.__bases__: - bases = list(ns0.MethodDisabled_Def.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.MethodDisabled_Def.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationDisabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.MigrationDisabled_Def.__bases__: - bases = list(ns0.MigrationDisabled_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.MigrationDisabled_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.MigrationFault_Def.__bases__: - bases = list(ns0.MigrationFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.MigrationFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationFeatureNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationFeatureNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationFeatureNotSupported_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"atSourceHost"), aname="_atSourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"failedHostName"), aname="_failedHostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"failedHost"), aname="_failedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.MigrationFeatureNotSupported_Def.__bases__: - bases = list(ns0.MigrationFeatureNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.MigrationFeatureNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MigrationNotReady_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MigrationNotReady") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MigrationNotReady_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.MigrationNotReady_Def.__bases__: - bases = list(ns0.MigrationNotReady_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.MigrationNotReady_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MismatchedBundle_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MismatchedBundle") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MismatchedBundle_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"bundleUuid"), aname="_bundleUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostUuid"), aname="_hostUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"bundleBuildNumber"), aname="_bundleBuildNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostBuildNumber"), aname="_hostBuildNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.MismatchedBundle_Def.__bases__: - bases = list(ns0.MismatchedBundle_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.MismatchedBundle_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MismatchedNetworkPolicies_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MismatchedNetworkPolicies") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MismatchedNetworkPolicies_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.MismatchedNetworkPolicies_Def.__bases__: - bases = list(ns0.MismatchedNetworkPolicies_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.MismatchedNetworkPolicies_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MismatchedVMotionNetworkNames_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MismatchedVMotionNetworkNames") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MismatchedVMotionNetworkNames_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"sourceNetwork"), aname="_sourceNetwork", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"destNetwork"), aname="_destNetwork", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.MismatchedVMotionNetworkNames_Def.__bases__: - bases = list(ns0.MismatchedVMotionNetworkNames_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.MismatchedVMotionNetworkNames_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MissingBmcSupport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingBmcSupport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingBmcSupport_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.MissingBmcSupport_Def.__bases__: - bases = list(ns0.MissingBmcSupport_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.MissingBmcSupport_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MissingController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidDeviceSpec_Def not in ns0.MissingController_Def.__bases__: - bases = list(ns0.MissingController_Def.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.MissingController_Def.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MissingLinuxCustResources_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingLinuxCustResources") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingLinuxCustResources_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.MissingLinuxCustResources_Def.__bases__: - bases = list(ns0.MissingLinuxCustResources_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.MissingLinuxCustResources_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MissingNetworkIpConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingNetworkIpConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingNetworkIpConfig_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppPropertyFault_Def not in ns0.MissingNetworkIpConfig_Def.__bases__: - bases = list(ns0.MissingNetworkIpConfig_Def.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.MissingNetworkIpConfig_Def.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MissingPowerOffConfiguration_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingPowerOffConfiguration") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingPowerOffConfiguration_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppConfigFault_Def not in ns0.MissingPowerOffConfiguration_Def.__bases__: - bases = list(ns0.MissingPowerOffConfiguration_Def.__bases__) - bases.insert(0, ns0.VAppConfigFault_Def) - ns0.MissingPowerOffConfiguration_Def.__bases__ = tuple(bases) - - ns0.VAppConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MissingPowerOnConfiguration_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingPowerOnConfiguration") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingPowerOnConfiguration_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppConfigFault_Def not in ns0.MissingPowerOnConfiguration_Def.__bases__: - bases = list(ns0.MissingPowerOnConfiguration_Def.__bases__) - bases.insert(0, ns0.VAppConfigFault_Def) - ns0.MissingPowerOnConfiguration_Def.__bases__ = tuple(bases) - - ns0.VAppConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MissingWindowsCustResources_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MissingWindowsCustResources") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MissingWindowsCustResources_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.MissingWindowsCustResources_Def.__bases__: - bases = list(ns0.MissingWindowsCustResources_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.MissingWindowsCustResources_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MountError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MountError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MountError_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"diskIndex"), aname="_diskIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.MountError_Def.__bases__: - bases = list(ns0.MountError_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.MountError_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MultipleCertificatesVerifyFaultThumbprintData_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MultipleCertificatesVerifyFaultThumbprintData") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"thumbprint"), aname="_thumbprint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.__bases__: - bases = list(ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.MultipleCertificatesVerifyFaultThumbprintData_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfMultipleCertificatesVerifyFaultThumbprintData_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfMultipleCertificatesVerifyFaultThumbprintData") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfMultipleCertificatesVerifyFaultThumbprintData_Def.schema - TClist = [GTD("urn:vim25","MultipleCertificatesVerifyFaultThumbprintData",lazy=True)(pname=(ns,"MultipleCertificatesVerifyFaultThumbprintData"), aname="_MultipleCertificatesVerifyFaultThumbprintData", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._MultipleCertificatesVerifyFaultThumbprintData = [] - return - Holder.__name__ = "ArrayOfMultipleCertificatesVerifyFaultThumbprintData_Holder" - self.pyclass = Holder - - class MultipleCertificatesVerifyFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MultipleCertificatesVerifyFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MultipleCertificatesVerifyFault_Def.schema - TClist = [GTD("urn:vim25","MultipleCertificatesVerifyFaultThumbprintData",lazy=True)(pname=(ns,"thumbprintData"), aname="_thumbprintData", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.MultipleCertificatesVerifyFault_Def.__bases__: - bases = list(ns0.MultipleCertificatesVerifyFault_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.MultipleCertificatesVerifyFault_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MultipleSnapshotsNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MultipleSnapshotsNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MultipleSnapshotsNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.MultipleSnapshotsNotSupported_Def.__bases__: - bases = list(ns0.MultipleSnapshotsNotSupported_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.MultipleSnapshotsNotSupported_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NasConfigFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NasConfigFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NasConfigFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.NasConfigFault_Def.__bases__: - bases = list(ns0.NasConfigFault_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.NasConfigFault_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NasConnectionLimitReached_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NasConnectionLimitReached") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NasConnectionLimitReached_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NasConfigFault_Def not in ns0.NasConnectionLimitReached_Def.__bases__: - bases = list(ns0.NasConnectionLimitReached_Def.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.NasConnectionLimitReached_Def.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NasSessionCredentialConflict_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NasSessionCredentialConflict") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NasSessionCredentialConflict_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NasConfigFault_Def not in ns0.NasSessionCredentialConflict_Def.__bases__: - bases = list(ns0.NasSessionCredentialConflict_Def.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.NasSessionCredentialConflict_Def.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NasVolumeNotMounted_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NasVolumeNotMounted") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NasVolumeNotMounted_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NasConfigFault_Def not in ns0.NasVolumeNotMounted_Def.__bases__: - bases = list(ns0.NasVolumeNotMounted_Def.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.NasVolumeNotMounted_Def.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NetworkCopyFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworkCopyFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworkCopyFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.NetworkCopyFault_Def.__bases__: - bases = list(ns0.NetworkCopyFault_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.NetworkCopyFault_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NetworkInaccessible_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworkInaccessible") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworkInaccessible_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NasConfigFault_Def not in ns0.NetworkInaccessible_Def.__bases__: - bases = list(ns0.NetworkInaccessible_Def.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.NetworkInaccessible_Def.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NetworksMayNotBeTheSame_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworksMayNotBeTheSame") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworksMayNotBeTheSame_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.NetworksMayNotBeTheSame_Def.__bases__: - bases = list(ns0.NetworksMayNotBeTheSame_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.NetworksMayNotBeTheSame_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NicSettingMismatch_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NicSettingMismatch") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NicSettingMismatch_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numberOfNicsInSpec"), aname="_numberOfNicsInSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numberOfNicsInVM"), aname="_numberOfNicsInVM", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.NicSettingMismatch_Def.__bases__: - bases = list(ns0.NicSettingMismatch_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.NicSettingMismatch_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoActiveHostInCluster_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoActiveHostInCluster") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoActiveHostInCluster_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"computeResource"), aname="_computeResource", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidState_Def not in ns0.NoActiveHostInCluster_Def.__bases__: - bases = list(ns0.NoActiveHostInCluster_Def.__bases__) - bases.insert(0, ns0.InvalidState_Def) - ns0.NoActiveHostInCluster_Def.__bases__ = tuple(bases) - - ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoAvailableIp_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoAvailableIp") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoAvailableIp_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppPropertyFault_Def not in ns0.NoAvailableIp_Def.__bases__: - bases = list(ns0.NoAvailableIp_Def.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.NoAvailableIp_Def.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoClientCertificate_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoClientCertificate") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoClientCertificate_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.NoClientCertificate_Def.__bases__: - bases = list(ns0.NoClientCertificate_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.NoClientCertificate_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoCompatibleHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoCompatibleHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoCompatibleHost_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.NoCompatibleHost_Def.__bases__: - bases = list(ns0.NoCompatibleHost_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.NoCompatibleHost_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoDiskFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoDiskFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoDiskFound_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.NoDiskFound_Def.__bases__: - bases = list(ns0.NoDiskFound_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.NoDiskFound_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoDiskSpace_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoDiskSpace") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoDiskSpace_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileFault_Def not in ns0.NoDiskSpace_Def.__bases__: - bases = list(ns0.NoDiskSpace_Def.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.NoDiskSpace_Def.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoDisksToCustomize_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoDisksToCustomize") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoDisksToCustomize_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.NoDisksToCustomize_Def.__bases__: - bases = list(ns0.NoDisksToCustomize_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.NoDisksToCustomize_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoGateway_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoGateway") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoGateway_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.NoGateway_Def.__bases__: - bases = list(ns0.NoGateway_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.NoGateway_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoGuestHeartbeat_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoGuestHeartbeat") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoGuestHeartbeat_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.NoGuestHeartbeat_Def.__bases__: - bases = list(ns0.NoGuestHeartbeat_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.NoGuestHeartbeat_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoHost_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.NoHost_Def.__bases__: - bases = list(ns0.NoHost_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.NoHost_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoHostSuitableForFtSecondary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoHostSuitableForFtSecondary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoHostSuitableForFtSecondary_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.NoHostSuitableForFtSecondary_Def.__bases__: - bases = list(ns0.NoHostSuitableForFtSecondary_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.NoHostSuitableForFtSecondary_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoLicenseServerConfigured_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoLicenseServerConfigured") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoLicenseServerConfigured_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.NoLicenseServerConfigured_Def.__bases__: - bases = list(ns0.NoLicenseServerConfigured_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.NoLicenseServerConfigured_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoPeerHostFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoPeerHostFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoPeerHostFound_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostPowerOpFailed_Def not in ns0.NoPeerHostFound_Def.__bases__: - bases = list(ns0.NoPeerHostFound_Def.__bases__) - bases.insert(0, ns0.HostPowerOpFailed_Def) - ns0.NoPeerHostFound_Def.__bases__ = tuple(bases) - - ns0.HostPowerOpFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoPermission_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoPermission") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoPermission_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"object"), aname="_object", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"privilegeId"), aname="_privilegeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SecurityError_Def not in ns0.NoPermission_Def.__bases__: - bases = list(ns0.NoPermission_Def.__bases__) - bases.insert(0, ns0.SecurityError_Def) - ns0.NoPermission_Def.__bases__ = tuple(bases) - - ns0.SecurityError_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoPermissionOnHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoPermissionOnHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoPermissionOnHost_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.NoPermissionOnHost_Def.__bases__: - bases = list(ns0.NoPermissionOnHost_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.NoPermissionOnHost_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoPermissionOnNasVolume_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoPermissionOnNasVolume") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoPermissionOnNasVolume_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NasConfigFault_Def not in ns0.NoPermissionOnNasVolume_Def.__bases__: - bases = list(ns0.NoPermissionOnNasVolume_Def.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.NoPermissionOnNasVolume_Def.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoSubjectName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoSubjectName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoSubjectName_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.NoSubjectName_Def.__bases__: - bases = list(ns0.NoSubjectName_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.NoSubjectName_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoVcManagedIpConfigured_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoVcManagedIpConfigured") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoVcManagedIpConfigured_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppPropertyFault_Def not in ns0.NoVcManagedIpConfigured_Def.__bases__: - bases = list(ns0.NoVcManagedIpConfigured_Def.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.NoVcManagedIpConfigured_Def.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoVirtualNic_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoVirtualNic") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoVirtualNic_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.NoVirtualNic_Def.__bases__: - bases = list(ns0.NoVirtualNic_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.NoVirtualNic_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NoVmInVApp_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NoVmInVApp") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NoVmInVApp_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppConfigFault_Def not in ns0.NoVmInVApp_Def.__bases__: - bases = list(ns0.NoVmInVApp_Def.__bases__) - bases.insert(0, ns0.VAppConfigFault_Def) - ns0.NoVmInVApp_Def.__bases__ = tuple(bases) - - ns0.VAppConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NonHomeRDMVMotionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NonHomeRDMVMotionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NonHomeRDMVMotionNotSupported_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFeatureNotSupported_Def not in ns0.NonHomeRDMVMotionNotSupported_Def.__bases__: - bases = list(ns0.NonHomeRDMVMotionNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFeatureNotSupported_Def) - ns0.NonHomeRDMVMotionNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NonPersistentDisksNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NonPersistentDisksNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NonPersistentDisksNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.NonPersistentDisksNotSupported_Def.__bases__: - bases = list(ns0.NonPersistentDisksNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.NonPersistentDisksNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotAuthenticated_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotAuthenticated") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotAuthenticated_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NoPermission_Def not in ns0.NotAuthenticated_Def.__bases__: - bases = list(ns0.NotAuthenticated_Def.__bases__) - bases.insert(0, ns0.NoPermission_Def) - ns0.NotAuthenticated_Def.__bases__ = tuple(bases) - - ns0.NoPermission_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotEnoughCpus_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotEnoughCpus") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotEnoughCpus_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numCpuDest"), aname="_numCpuDest", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuVm"), aname="_numCpuVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.NotEnoughCpus_Def.__bases__: - bases = list(ns0.NotEnoughCpus_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.NotEnoughCpus_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotEnoughLogicalCpus_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotEnoughLogicalCpus") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotEnoughLogicalCpus_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughCpus_Def not in ns0.NotEnoughLogicalCpus_Def.__bases__: - bases = list(ns0.NotEnoughLogicalCpus_Def.__bases__) - bases.insert(0, ns0.NotEnoughCpus_Def) - ns0.NotEnoughLogicalCpus_Def.__bases__ = tuple(bases) - - ns0.NotEnoughCpus_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotFound_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.NotFound_Def.__bases__: - bases = list(ns0.NotFound_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.NotFound_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotSupportedHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotSupportedHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotSupportedHost_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"productName"), aname="_productName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productVersion"), aname="_productVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.NotSupportedHost_Def.__bases__: - bases = list(ns0.NotSupportedHost_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.NotSupportedHost_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotSupportedHostInCluster_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotSupportedHostInCluster") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotSupportedHostInCluster_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotSupportedHost_Def not in ns0.NotSupportedHostInCluster_Def.__bases__: - bases = list(ns0.NotSupportedHostInCluster_Def.__bases__) - bases.insert(0, ns0.NotSupportedHost_Def) - ns0.NotSupportedHostInCluster_Def.__bases__ = tuple(bases) - - ns0.NotSupportedHost_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NotUserConfigurableProperty_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NotUserConfigurableProperty") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NotUserConfigurableProperty_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VAppPropertyFault_Def not in ns0.NotUserConfigurableProperty_Def.__bases__: - bases = list(ns0.NotUserConfigurableProperty_Def.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.NotUserConfigurableProperty_Def.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NumVirtualCpusIncompatibleReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "NumVirtualCpusIncompatibleReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class NumVirtualCpusIncompatible_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NumVirtualCpusIncompatible") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NumVirtualCpusIncompatible_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpu"), aname="_numCpu", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.NumVirtualCpusIncompatible_Def.__bases__: - bases = list(ns0.NumVirtualCpusIncompatible_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.NumVirtualCpusIncompatible_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NumVirtualCpusNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NumVirtualCpusNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NumVirtualCpusNotSupported_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"maxSupportedVcpusDest"), aname="_maxSupportedVcpusDest", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuVm"), aname="_numCpuVm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.NumVirtualCpusNotSupported_Def.__bases__: - bases = list(ns0.NumVirtualCpusNotSupported_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.NumVirtualCpusNotSupported_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OutOfBounds_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OutOfBounds") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OutOfBounds_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"argumentName"), aname="_argumentName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.OutOfBounds_Def.__bases__: - bases = list(ns0.OutOfBounds_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.OutOfBounds_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfAttribute_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfAttribute") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfAttribute_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"attributeName"), aname="_attributeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidPackage_Def not in ns0.OvfAttribute_Def.__bases__: - bases = list(ns0.OvfAttribute_Def.__bases__) - bases.insert(0, ns0.OvfInvalidPackage_Def) - ns0.OvfAttribute_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfConnectedDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfConnectedDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfConnectedDevice_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfHardwareExport_Def not in ns0.OvfConnectedDevice_Def.__bases__: - bases = list(ns0.OvfConnectedDevice_Def.__bases__) - bases.insert(0, ns0.OvfHardwareExport_Def) - ns0.OvfConnectedDevice_Def.__bases__ = tuple(bases) - - ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfConnectedDeviceFloppy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfConnectedDeviceFloppy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfConnectedDeviceFloppy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfConnectedDevice_Def not in ns0.OvfConnectedDeviceFloppy_Def.__bases__: - bases = list(ns0.OvfConnectedDeviceFloppy_Def.__bases__) - bases.insert(0, ns0.OvfConnectedDevice_Def) - ns0.OvfConnectedDeviceFloppy_Def.__bases__ = tuple(bases) - - ns0.OvfConnectedDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfConnectedDeviceIso_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfConnectedDeviceIso") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfConnectedDeviceIso_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfConnectedDevice_Def not in ns0.OvfConnectedDeviceIso_Def.__bases__: - bases = list(ns0.OvfConnectedDeviceIso_Def.__bases__) - bases.insert(0, ns0.OvfConnectedDevice_Def) - ns0.OvfConnectedDeviceIso_Def.__bases__ = tuple(bases) - - ns0.OvfConnectedDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfDiskMappingNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfDiskMappingNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfDiskMappingNotFound_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskName"), aname="_diskName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfSystemFault_Def not in ns0.OvfDiskMappingNotFound_Def.__bases__: - bases = list(ns0.OvfDiskMappingNotFound_Def.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfDiskMappingNotFound_Def.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfDuplicateElement_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfDuplicateElement") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfDuplicateElement_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfElement_Def not in ns0.OvfDuplicateElement_Def.__bases__: - bases = list(ns0.OvfDuplicateElement_Def.__bases__) - bases.insert(0, ns0.OvfElement_Def) - ns0.OvfDuplicateElement_Def.__bases__ = tuple(bases) - - ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfDuplicatedElementBoundary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfDuplicatedElementBoundary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfDuplicatedElementBoundary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"boundary"), aname="_boundary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfElement_Def not in ns0.OvfDuplicatedElementBoundary_Def.__bases__: - bases = list(ns0.OvfDuplicatedElementBoundary_Def.__bases__) - bases.insert(0, ns0.OvfElement_Def) - ns0.OvfDuplicatedElementBoundary_Def.__bases__ = tuple(bases) - - ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfElement_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfElement") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfElement_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidPackage_Def not in ns0.OvfElement_Def.__bases__: - bases = list(ns0.OvfElement_Def.__bases__) - bases.insert(0, ns0.OvfInvalidPackage_Def) - ns0.OvfElement_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfElementInvalidValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfElementInvalidValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfElementInvalidValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfElement_Def not in ns0.OvfElementInvalidValue_Def.__bases__: - bases = list(ns0.OvfElementInvalidValue_Def.__bases__) - bases.insert(0, ns0.OvfElement_Def) - ns0.OvfElementInvalidValue_Def.__bases__ = tuple(bases) - - ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfExport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfExport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfExport_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfFault_Def not in ns0.OvfExport_Def.__bases__: - bases = list(ns0.OvfExport_Def.__bases__) - bases.insert(0, ns0.OvfFault_Def) - ns0.OvfExport_Def.__bases__ = tuple(bases) - - ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.OvfFault_Def.__bases__: - bases = list(ns0.OvfFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.OvfFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfHardwareCheck_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfHardwareCheck") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfHardwareCheck_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfImport_Def not in ns0.OvfHardwareCheck_Def.__bases__: - bases = list(ns0.OvfHardwareCheck_Def.__bases__) - bases.insert(0, ns0.OvfImport_Def) - ns0.OvfHardwareCheck_Def.__bases__ = tuple(bases) - - ns0.OvfImport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfHardwareExport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfHardwareExport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfHardwareExport_Def.schema - TClist = [GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmPath"), aname="_vmPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfExport_Def not in ns0.OvfHardwareExport_Def.__bases__: - bases = list(ns0.OvfHardwareExport_Def.__bases__) - bases.insert(0, ns0.OvfExport_Def) - ns0.OvfHardwareExport_Def.__bases__ = tuple(bases) - - ns0.OvfExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfHostValueNotParsed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfHostValueNotParsed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfHostValueNotParsed_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfSystemFault_Def not in ns0.OvfHostValueNotParsed_Def.__bases__: - bases = list(ns0.OvfHostValueNotParsed_Def.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfHostValueNotParsed_Def.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfImport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfImport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfImport_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfFault_Def not in ns0.OvfImport_Def.__bases__: - bases = list(ns0.OvfImport_Def.__bases__) - bases.insert(0, ns0.OvfFault_Def) - ns0.OvfImport_Def.__bases__ = tuple(bases) - - ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfInvalidPackage_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfInvalidPackage") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfInvalidPackage_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineNumber"), aname="_lineNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfFault_Def not in ns0.OvfInvalidPackage_Def.__bases__: - bases = list(ns0.OvfInvalidPackage_Def.__bases__) - bases.insert(0, ns0.OvfFault_Def) - ns0.OvfInvalidPackage_Def.__bases__ = tuple(bases) - - ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfInvalidValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfInvalidValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfInvalidValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfAttribute_Def not in ns0.OvfInvalidValue_Def.__bases__: - bases = list(ns0.OvfInvalidValue_Def.__bases__) - bases.insert(0, ns0.OvfAttribute_Def) - ns0.OvfInvalidValue_Def.__bases__ = tuple(bases) - - ns0.OvfAttribute_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfInvalidValueConfiguration_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfInvalidValueConfiguration") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfInvalidValueConfiguration_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueConfiguration_Def.__bases__: - bases = list(ns0.OvfInvalidValueConfiguration_Def.__bases__) - bases.insert(0, ns0.OvfInvalidValue_Def) - ns0.OvfInvalidValueConfiguration_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfInvalidValueEmpty_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfInvalidValueEmpty") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfInvalidValueEmpty_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueEmpty_Def.__bases__: - bases = list(ns0.OvfInvalidValueEmpty_Def.__bases__) - bases.insert(0, ns0.OvfInvalidValue_Def) - ns0.OvfInvalidValueEmpty_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfInvalidValueFormatMalformed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfInvalidValueFormatMalformed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfInvalidValueFormatMalformed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueFormatMalformed_Def.__bases__: - bases = list(ns0.OvfInvalidValueFormatMalformed_Def.__bases__) - bases.insert(0, ns0.OvfInvalidValue_Def) - ns0.OvfInvalidValueFormatMalformed_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfInvalidValueReference_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfInvalidValueReference") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfInvalidValueReference_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueReference_Def.__bases__: - bases = list(ns0.OvfInvalidValueReference_Def.__bases__) - bases.insert(0, ns0.OvfInvalidValue_Def) - ns0.OvfInvalidValueReference_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfInvalidVmName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfInvalidVmName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfInvalidVmName_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfInvalidVmName_Def.__bases__: - bases = list(ns0.OvfInvalidVmName_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfInvalidVmName_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfMappedOsId_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfMappedOsId") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfMappedOsId_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"ovfId"), aname="_ovfId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfDescription"), aname="_ovfDescription", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"targetDescription"), aname="_targetDescription", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfImport_Def not in ns0.OvfMappedOsId_Def.__bases__: - bases = list(ns0.OvfMappedOsId_Def.__bases__) - bases.insert(0, ns0.OvfImport_Def) - ns0.OvfMappedOsId_Def.__bases__ = tuple(bases) - - ns0.OvfImport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfMissingAttribute_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfMissingAttribute") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfMissingAttribute_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfAttribute_Def not in ns0.OvfMissingAttribute_Def.__bases__: - bases = list(ns0.OvfMissingAttribute_Def.__bases__) - bases.insert(0, ns0.OvfAttribute_Def) - ns0.OvfMissingAttribute_Def.__bases__ = tuple(bases) - - ns0.OvfAttribute_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfMissingElement_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfMissingElement") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfMissingElement_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfElement_Def not in ns0.OvfMissingElement_Def.__bases__: - bases = list(ns0.OvfMissingElement_Def.__bases__) - bases.insert(0, ns0.OvfElement_Def) - ns0.OvfMissingElement_Def.__bases__ = tuple(bases) - - ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfMissingElementNormalBoundary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfMissingElementNormalBoundary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfMissingElementNormalBoundary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"boundary"), aname="_boundary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfMissingElement_Def not in ns0.OvfMissingElementNormalBoundary_Def.__bases__: - bases = list(ns0.OvfMissingElementNormalBoundary_Def.__bases__) - bases.insert(0, ns0.OvfMissingElement_Def) - ns0.OvfMissingElementNormalBoundary_Def.__bases__ = tuple(bases) - - ns0.OvfMissingElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfMissingHardware_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfMissingHardware") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfMissingHardware_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"resourceType"), aname="_resourceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfImport_Def not in ns0.OvfMissingHardware_Def.__bases__: - bases = list(ns0.OvfMissingHardware_Def.__bases__) - bases.insert(0, ns0.OvfImport_Def) - ns0.OvfMissingHardware_Def.__bases__ = tuple(bases) - - ns0.OvfImport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfNoHostNic_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfNoHostNic") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfNoHostNic_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfNoHostNic_Def.__bases__: - bases = list(ns0.OvfNoHostNic_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfNoHostNic_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfNoSupportedHardwareFamily_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfNoSupportedHardwareFamily") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfNoSupportedHardwareFamily_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfNoSupportedHardwareFamily_Def.__bases__: - bases = list(ns0.OvfNoSupportedHardwareFamily_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfNoSupportedHardwareFamily_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfProperty_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfProperty") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfProperty_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidPackage_Def not in ns0.OvfProperty_Def.__bases__: - bases = list(ns0.OvfProperty_Def.__bases__) - bases.insert(0, ns0.OvfInvalidPackage_Def) - ns0.OvfProperty_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfPropertyExport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfPropertyExport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfPropertyExport_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfExport_Def not in ns0.OvfPropertyExport_Def.__bases__: - bases = list(ns0.OvfPropertyExport_Def.__bases__) - bases.insert(0, ns0.OvfExport_Def) - ns0.OvfPropertyExport_Def.__bases__ = tuple(bases) - - ns0.OvfExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfPropertyNetwork_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfPropertyNetwork") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfPropertyNetwork_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfProperty_Def not in ns0.OvfPropertyNetwork_Def.__bases__: - bases = list(ns0.OvfPropertyNetwork_Def.__bases__) - bases.insert(0, ns0.OvfProperty_Def) - ns0.OvfPropertyNetwork_Def.__bases__ = tuple(bases) - - ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfPropertyQualifier_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfPropertyQualifier") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfPropertyQualifier_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"qualifier"), aname="_qualifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfProperty_Def not in ns0.OvfPropertyQualifier_Def.__bases__: - bases = list(ns0.OvfPropertyQualifier_Def.__bases__) - bases.insert(0, ns0.OvfProperty_Def) - ns0.OvfPropertyQualifier_Def.__bases__ = tuple(bases) - - ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfPropertyQualifierDuplicate_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfPropertyQualifierDuplicate") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfPropertyQualifierDuplicate_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"qualifier"), aname="_qualifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfProperty_Def not in ns0.OvfPropertyQualifierDuplicate_Def.__bases__: - bases = list(ns0.OvfPropertyQualifierDuplicate_Def.__bases__) - bases.insert(0, ns0.OvfProperty_Def) - ns0.OvfPropertyQualifierDuplicate_Def.__bases__ = tuple(bases) - - ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfPropertyQualifierIgnored_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfPropertyQualifierIgnored") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfPropertyQualifierIgnored_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"qualifier"), aname="_qualifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfProperty_Def not in ns0.OvfPropertyQualifierIgnored_Def.__bases__: - bases = list(ns0.OvfPropertyQualifierIgnored_Def.__bases__) - bases.insert(0, ns0.OvfProperty_Def) - ns0.OvfPropertyQualifierIgnored_Def.__bases__ = tuple(bases) - - ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfPropertyType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfPropertyType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfPropertyType_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfProperty_Def not in ns0.OvfPropertyType_Def.__bases__: - bases = list(ns0.OvfPropertyType_Def.__bases__) - bases.insert(0, ns0.OvfProperty_Def) - ns0.OvfPropertyType_Def.__bases__ = tuple(bases) - - ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfPropertyValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfPropertyValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfPropertyValue_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfProperty_Def not in ns0.OvfPropertyValue_Def.__bases__: - bases = list(ns0.OvfPropertyValue_Def.__bases__) - bases.insert(0, ns0.OvfProperty_Def) - ns0.OvfPropertyValue_Def.__bases__ = tuple(bases) - - ns0.OvfProperty_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfSystemFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfSystemFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfSystemFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfFault_Def not in ns0.OvfSystemFault_Def.__bases__: - bases = list(ns0.OvfSystemFault_Def.__bases__) - bases.insert(0, ns0.OvfFault_Def) - ns0.OvfSystemFault_Def.__bases__ = tuple(bases) - - ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfToXmlUnsupportedElement_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfToXmlUnsupportedElement") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfToXmlUnsupportedElement_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfSystemFault_Def not in ns0.OvfToXmlUnsupportedElement_Def.__bases__: - bases = list(ns0.OvfToXmlUnsupportedElement_Def.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfToXmlUnsupportedElement_Def.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnableToExportDisk_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnableToExportDisk") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnableToExportDisk_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskName"), aname="_diskName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfHardwareExport_Def not in ns0.OvfUnableToExportDisk_Def.__bases__: - bases = list(ns0.OvfUnableToExportDisk_Def.__bases__) - bases.insert(0, ns0.OvfHardwareExport_Def) - ns0.OvfUnableToExportDisk_Def.__bases__ = tuple(bases) - - ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnexpectedElement_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnexpectedElement") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnexpectedElement_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfElement_Def not in ns0.OvfUnexpectedElement_Def.__bases__: - bases = list(ns0.OvfUnexpectedElement_Def.__bases__) - bases.insert(0, ns0.OvfElement_Def) - ns0.OvfUnexpectedElement_Def.__bases__ = tuple(bases) - - ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnknownDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnknownDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnknownDevice_Def.schema - TClist = [GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfSystemFault_Def not in ns0.OvfUnknownDevice_Def.__bases__: - bases = list(ns0.OvfUnknownDevice_Def.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfUnknownDevice_Def.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnknownDeviceBacking_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnknownDeviceBacking") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnknownDeviceBacking_Def.schema - TClist = [GTD("urn:vim25","VirtualDeviceBackingInfo",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfHardwareExport_Def not in ns0.OvfUnknownDeviceBacking_Def.__bases__: - bases = list(ns0.OvfUnknownDeviceBacking_Def.__bases__) - bases.insert(0, ns0.OvfHardwareExport_Def) - ns0.OvfUnknownDeviceBacking_Def.__bases__ = tuple(bases) - - ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnknownEntity_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnknownEntity") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnknownEntity_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineNumber"), aname="_lineNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfSystemFault_Def not in ns0.OvfUnknownEntity_Def.__bases__: - bases = list(ns0.OvfUnknownEntity_Def.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfUnknownEntity_Def.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedAttribute_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedAttribute") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedAttribute_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"attributeName"), aname="_attributeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedAttribute_Def.__bases__: - bases = list(ns0.OvfUnsupportedAttribute_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfUnsupportedAttribute_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedAttributeValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedAttributeValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedAttributeValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedAttribute_Def not in ns0.OvfUnsupportedAttributeValue_Def.__bases__: - bases = list(ns0.OvfUnsupportedAttributeValue_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedAttribute_Def) - ns0.OvfUnsupportedAttributeValue_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedAttribute_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedDeviceBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backingName"), aname="_backingName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfSystemFault_Def not in ns0.OvfUnsupportedDeviceBackingInfo_Def.__bases__: - bases = list(ns0.OvfUnsupportedDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfUnsupportedDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedDeviceBackingOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backingName"), aname="_backingName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfSystemFault_Def not in ns0.OvfUnsupportedDeviceBackingOption_Def.__bases__: - bases = list(ns0.OvfUnsupportedDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfUnsupportedDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedDeviceExport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedDeviceExport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedDeviceExport_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfHardwareExport_Def not in ns0.OvfUnsupportedDeviceExport_Def.__bases__: - bases = list(ns0.OvfUnsupportedDeviceExport_Def.__bases__) - bases.insert(0, ns0.OvfHardwareExport_Def) - ns0.OvfUnsupportedDeviceExport_Def.__bases__ = tuple(bases) - - ns0.OvfHardwareExport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedElement_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedElement") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedElement_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedElement_Def.__bases__: - bases = list(ns0.OvfUnsupportedElement_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfUnsupportedElement_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedElementValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedElementValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedElementValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedElement_Def not in ns0.OvfUnsupportedElementValue_Def.__bases__: - bases = list(ns0.OvfUnsupportedElementValue_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedElement_Def) - ns0.OvfUnsupportedElementValue_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedPackage_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedPackage") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedPackage_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"lineNumber"), aname="_lineNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfFault_Def not in ns0.OvfUnsupportedPackage_Def.__bases__: - bases = list(ns0.OvfUnsupportedPackage_Def.__bases__) - bases.insert(0, ns0.OvfFault_Def) - ns0.OvfUnsupportedPackage_Def.__bases__ = tuple(bases) - - ns0.OvfFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedSection_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedSection") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedSection_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedElement_Def not in ns0.OvfUnsupportedSection_Def.__bases__: - bases = list(ns0.OvfUnsupportedSection_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedElement_Def) - ns0.OvfUnsupportedSection_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedSubType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedSubType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedSubType_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"elementName"), aname="_elementName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceType"), aname="_deviceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceSubType"), aname="_deviceSubType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedSubType_Def.__bases__: - bases = list(ns0.OvfUnsupportedSubType_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfUnsupportedSubType_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfUnsupportedType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfUnsupportedType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfUnsupportedType_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceType"), aname="_deviceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedType_Def.__bases__: - bases = list(ns0.OvfUnsupportedType_Def.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfUnsupportedType_Def.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfWrongElement_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfWrongElement") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfWrongElement_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfElement_Def not in ns0.OvfWrongElement_Def.__bases__: - bases = list(ns0.OvfWrongElement_Def.__bases__) - bases.insert(0, ns0.OvfElement_Def) - ns0.OvfWrongElement_Def.__bases__ = tuple(bases) - - ns0.OvfElement_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfWrongNamespace_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfWrongNamespace") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfWrongNamespace_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"namespaceName"), aname="_namespaceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidPackage_Def not in ns0.OvfWrongNamespace_Def.__bases__: - bases = list(ns0.OvfWrongNamespace_Def.__bases__) - bases.insert(0, ns0.OvfInvalidPackage_Def) - ns0.OvfWrongNamespace_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OvfXmlFormat_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OvfXmlFormat") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OvfXmlFormat_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OvfInvalidPackage_Def not in ns0.OvfXmlFormat_Def.__bases__: - bases = list(ns0.OvfXmlFormat_Def.__bases__) - bases.insert(0, ns0.OvfInvalidPackage_Def) - ns0.OvfXmlFormat_Def.__bases__ = tuple(bases) - - ns0.OvfInvalidPackage_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchAlreadyInstalled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchAlreadyInstalled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchAlreadyInstalled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PatchNotApplicable_Def not in ns0.PatchAlreadyInstalled_Def.__bases__: - bases = list(ns0.PatchAlreadyInstalled_Def.__bases__) - bases.insert(0, ns0.PatchNotApplicable_Def) - ns0.PatchAlreadyInstalled_Def.__bases__ = tuple(bases) - - ns0.PatchNotApplicable_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchBinariesNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchBinariesNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchBinariesNotFound_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"patchID"), aname="_patchID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"binary"), aname="_binary", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.PatchBinariesNotFound_Def.__bases__: - bases = list(ns0.PatchBinariesNotFound_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.PatchBinariesNotFound_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchInstallFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchInstallFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchInstallFailed_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"rolledBack"), aname="_rolledBack", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PlatformConfigFault_Def not in ns0.PatchInstallFailed_Def.__bases__: - bases = list(ns0.PatchInstallFailed_Def.__bases__) - bases.insert(0, ns0.PlatformConfigFault_Def) - ns0.PatchInstallFailed_Def.__bases__ = tuple(bases) - - ns0.PlatformConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchIntegrityError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchIntegrityError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchIntegrityError_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PlatformConfigFault_Def not in ns0.PatchIntegrityError_Def.__bases__: - bases = list(ns0.PatchIntegrityError_Def.__bases__) - bases.insert(0, ns0.PlatformConfigFault_Def) - ns0.PatchIntegrityError_Def.__bases__ = tuple(bases) - - ns0.PlatformConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchMetadataCorrupted_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchMetadataCorrupted") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchMetadataCorrupted_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PatchMetadataInvalid_Def not in ns0.PatchMetadataCorrupted_Def.__bases__: - bases = list(ns0.PatchMetadataCorrupted_Def.__bases__) - bases.insert(0, ns0.PatchMetadataInvalid_Def) - ns0.PatchMetadataCorrupted_Def.__bases__ = tuple(bases) - - ns0.PatchMetadataInvalid_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchMetadataInvalid_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchMetadataInvalid") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchMetadataInvalid_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"patchID"), aname="_patchID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaData"), aname="_metaData", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.PatchMetadataInvalid_Def.__bases__: - bases = list(ns0.PatchMetadataInvalid_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.PatchMetadataInvalid_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchMetadataNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchMetadataNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchMetadataNotFound_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PatchMetadataInvalid_Def not in ns0.PatchMetadataNotFound_Def.__bases__: - bases = list(ns0.PatchMetadataNotFound_Def.__bases__) - bases.insert(0, ns0.PatchMetadataInvalid_Def) - ns0.PatchMetadataNotFound_Def.__bases__ = tuple(bases) - - ns0.PatchMetadataInvalid_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchMissingDependencies_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchMissingDependencies") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchMissingDependencies_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"prerequisitePatch"), aname="_prerequisitePatch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"prerequisiteLib"), aname="_prerequisiteLib", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PatchNotApplicable_Def not in ns0.PatchMissingDependencies_Def.__bases__: - bases = list(ns0.PatchMissingDependencies_Def.__bases__) - bases.insert(0, ns0.PatchNotApplicable_Def) - ns0.PatchMissingDependencies_Def.__bases__ = tuple(bases) - - ns0.PatchNotApplicable_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchNotApplicable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchNotApplicable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchNotApplicable_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"patchID"), aname="_patchID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.PatchNotApplicable_Def.__bases__: - bases = list(ns0.PatchNotApplicable_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.PatchNotApplicable_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PatchSuperseded_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PatchSuperseded") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PatchSuperseded_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"supersede"), aname="_supersede", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PatchNotApplicable_Def not in ns0.PatchSuperseded_Def.__bases__: - bases = list(ns0.PatchSuperseded_Def.__bases__) - bases.insert(0, ns0.PatchNotApplicable_Def) - ns0.PatchSuperseded_Def.__bases__ = tuple(bases) - - ns0.PatchNotApplicable_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PhysCompatRDMNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysCompatRDMNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysCompatRDMNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RDMNotSupported_Def not in ns0.PhysCompatRDMNotSupported_Def.__bases__: - bases = list(ns0.PhysCompatRDMNotSupported_Def.__bases__) - bases.insert(0, ns0.RDMNotSupported_Def) - ns0.PhysCompatRDMNotSupported_Def.__bases__ = tuple(bases) - - ns0.RDMNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PlatformConfigFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PlatformConfigFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PlatformConfigFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"text"), aname="_text", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.PlatformConfigFault_Def.__bases__: - bases = list(ns0.PlatformConfigFault_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.PlatformConfigFault_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PowerOnFtSecondaryFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PowerOnFtSecondaryFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PowerOnFtSecondaryFailed_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FtIssuesOnHostHostSelectionType",lazy=True)(pname=(ns,"hostSelectionBy"), aname="_hostSelectionBy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"hostErrors"), aname="_hostErrors", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"rootCause"), aname="_rootCause", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.PowerOnFtSecondaryFailed_Def.__bases__: - bases = list(ns0.PowerOnFtSecondaryFailed_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.PowerOnFtSecondaryFailed_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PowerOnFtSecondaryTimedout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PowerOnFtSecondaryTimedout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PowerOnFtSecondaryTimedout_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmName"), aname="_vmName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.Timedout_Def not in ns0.PowerOnFtSecondaryTimedout_Def.__bases__: - bases = list(ns0.PowerOnFtSecondaryTimedout_Def.__bases__) - bases.insert(0, ns0.Timedout_Def) - ns0.PowerOnFtSecondaryTimedout_Def.__bases__ = tuple(bases) - - ns0.Timedout_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileUpdateFailedUpdateFailure_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileUpdateFailedUpdateFailure") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileUpdateFailedUpdateFailure_Def.schema - TClist = [GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"profilePath"), aname="_profilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"errMsg"), aname="_errMsg", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileUpdateFailedUpdateFailure_Def.__bases__: - bases = list(ns0.ProfileUpdateFailedUpdateFailure_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileUpdateFailedUpdateFailure_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileUpdateFailedUpdateFailure_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileUpdateFailedUpdateFailure") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileUpdateFailedUpdateFailure_Def.schema - TClist = [GTD("urn:vim25","ProfileUpdateFailedUpdateFailure",lazy=True)(pname=(ns,"ProfileUpdateFailedUpdateFailure"), aname="_ProfileUpdateFailedUpdateFailure", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileUpdateFailedUpdateFailure = [] - return - Holder.__name__ = "ArrayOfProfileUpdateFailedUpdateFailure_Holder" - self.pyclass = Holder - - class ProfileUpdateFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileUpdateFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileUpdateFailed_Def.schema - TClist = [GTD("urn:vim25","ProfileUpdateFailedUpdateFailure",lazy=True)(pname=(ns,"failure"), aname="_failure", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.ProfileUpdateFailed_Def.__bases__: - bases = list(ns0.ProfileUpdateFailed_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.ProfileUpdateFailed_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RDMConversionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RDMConversionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RDMConversionNotSupported_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.RDMConversionNotSupported_Def.__bases__: - bases = list(ns0.RDMConversionNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.RDMConversionNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RDMNotPreserved_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RDMNotPreserved") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RDMNotPreserved_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.RDMNotPreserved_Def.__bases__: - bases = list(ns0.RDMNotPreserved_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.RDMNotPreserved_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RDMNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RDMNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RDMNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.RDMNotSupported_Def.__bases__: - bases = list(ns0.RDMNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.RDMNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RDMNotSupportedOnDatastore_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RDMNotSupportedOnDatastore") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RDMNotSupportedOnDatastore_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastoreName"), aname="_datastoreName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.RDMNotSupportedOnDatastore_Def.__bases__: - bases = list(ns0.RDMNotSupportedOnDatastore_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.RDMNotSupportedOnDatastore_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RDMPointsToInaccessibleDisk_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RDMPointsToInaccessibleDisk") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RDMPointsToInaccessibleDisk_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessVmDisk_Def not in ns0.RDMPointsToInaccessibleDisk_Def.__bases__: - bases = list(ns0.RDMPointsToInaccessibleDisk_Def.__bases__) - bases.insert(0, ns0.CannotAccessVmDisk_Def) - ns0.RDMPointsToInaccessibleDisk_Def.__bases__ = tuple(bases) - - ns0.CannotAccessVmDisk_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RawDiskNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RawDiskNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RawDiskNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.RawDiskNotSupported_Def.__bases__: - bases = list(ns0.RawDiskNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.RawDiskNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReadOnlyDisksWithLegacyDestination_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ReadOnlyDisksWithLegacyDestination") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ReadOnlyDisksWithLegacyDestination_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"roDiskCount"), aname="_roDiskCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"timeoutDanger"), aname="_timeoutDanger", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.ReadOnlyDisksWithLegacyDestination_Def.__bases__: - bases = list(ns0.ReadOnlyDisksWithLegacyDestination_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.ReadOnlyDisksWithLegacyDestination_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RebootRequired_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RebootRequired") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RebootRequired_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"patch"), aname="_patch", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.RebootRequired_Def.__bases__: - bases = list(ns0.RebootRequired_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.RebootRequired_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RecordReplayDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RecordReplayDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RecordReplayDisabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.RecordReplayDisabled_Def.__bases__: - bases = list(ns0.RecordReplayDisabled_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.RecordReplayDisabled_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RemoteDeviceNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RemoteDeviceNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RemoteDeviceNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.RemoteDeviceNotSupported_Def.__bases__: - bases = list(ns0.RemoteDeviceNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.RemoteDeviceNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RemoveFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RemoveFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RemoveFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.RemoveFailed_Def.__bases__: - bases = list(ns0.RemoveFailed_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.RemoveFailed_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourceInUse_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourceInUse") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourceInUse_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.ResourceInUse_Def.__bases__: - bases = list(ns0.ResourceInUse_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.ResourceInUse_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ResourceNotAvailable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ResourceNotAvailable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ResourceNotAvailable_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"containerType"), aname="_containerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"containerName"), aname="_containerName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.ResourceNotAvailable_Def.__bases__: - bases = list(ns0.ResourceNotAvailable_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.ResourceNotAvailable_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RestrictedVersion_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RestrictedVersion") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RestrictedVersion_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SecurityError_Def not in ns0.RestrictedVersion_Def.__bases__: - bases = list(ns0.RestrictedVersion_Def.__bases__) - bases.insert(0, ns0.SecurityError_Def) - ns0.RestrictedVersion_Def.__bases__ = tuple(bases) - - ns0.SecurityError_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RuleViolation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RuleViolation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RuleViolation_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterRuleInfo",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.RuleViolation_Def.__bases__: - bases = list(ns0.RuleViolation_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.RuleViolation_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SSLDisabledFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SSLDisabledFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SSLDisabledFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.SSLDisabledFault_Def.__bases__: - bases = list(ns0.SSLDisabledFault_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.SSLDisabledFault_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SSLVerifyFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SSLVerifyFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SSLVerifyFault_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"selfSigned"), aname="_selfSigned", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"thumbprint"), aname="_thumbprint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.SSLVerifyFault_Def.__bases__: - bases = list(ns0.SSLVerifyFault_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.SSLVerifyFault_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SSPIChallenge_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SSPIChallenge") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SSPIChallenge_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"base64Token"), aname="_base64Token", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.SSPIChallenge_Def.__bases__: - bases = list(ns0.SSPIChallenge_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.SSPIChallenge_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SecondaryVmAlreadyDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SecondaryVmAlreadyDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SecondaryVmAlreadyDisabled_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmAlreadyDisabled_Def.__bases__: - bases = list(ns0.SecondaryVmAlreadyDisabled_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.SecondaryVmAlreadyDisabled_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SecondaryVmAlreadyEnabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SecondaryVmAlreadyEnabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SecondaryVmAlreadyEnabled_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmAlreadyEnabled_Def.__bases__: - bases = list(ns0.SecondaryVmAlreadyEnabled_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.SecondaryVmAlreadyEnabled_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SecondaryVmAlreadyRegistered_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SecondaryVmAlreadyRegistered") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SecondaryVmAlreadyRegistered_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmAlreadyRegistered_Def.__bases__: - bases = list(ns0.SecondaryVmAlreadyRegistered_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.SecondaryVmAlreadyRegistered_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SecondaryVmNotRegistered_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SecondaryVmNotRegistered") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SecondaryVmNotRegistered_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.SecondaryVmNotRegistered_Def.__bases__: - bases = list(ns0.SecondaryVmNotRegistered_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.SecondaryVmNotRegistered_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SharedBusControllerNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SharedBusControllerNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SharedBusControllerNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.SharedBusControllerNotSupported_Def.__bases__: - bases = list(ns0.SharedBusControllerNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.SharedBusControllerNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotCloneNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotCloneNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotCloneNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotCloneNotSupported_Def.__bases__: - bases = list(ns0.SnapshotCloneNotSupported_Def.__bases__) - bases.insert(0, ns0.SnapshotCopyNotSupported_Def) - ns0.SnapshotCloneNotSupported_Def.__bases__ = tuple(bases) - - ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotCopyNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotCopyNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotCopyNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.SnapshotCopyNotSupported_Def.__bases__: - bases = list(ns0.SnapshotCopyNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.SnapshotCopyNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotDisabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.SnapshotDisabled_Def.__bases__: - bases = list(ns0.SnapshotDisabled_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.SnapshotDisabled_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.SnapshotFault_Def.__bases__: - bases = list(ns0.SnapshotFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.SnapshotFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotIncompatibleDeviceInVm_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotIncompatibleDeviceInVm") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotIncompatibleDeviceInVm_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.SnapshotIncompatibleDeviceInVm_Def.__bases__: - bases = list(ns0.SnapshotIncompatibleDeviceInVm_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.SnapshotIncompatibleDeviceInVm_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotLocked_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotLocked") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotLocked_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.SnapshotLocked_Def.__bases__: - bases = list(ns0.SnapshotLocked_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.SnapshotLocked_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotMoveFromNonHomeNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotMoveFromNonHomeNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotMoveFromNonHomeNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotMoveFromNonHomeNotSupported_Def.__bases__: - bases = list(ns0.SnapshotMoveFromNonHomeNotSupported_Def.__bases__) - bases.insert(0, ns0.SnapshotCopyNotSupported_Def) - ns0.SnapshotMoveFromNonHomeNotSupported_Def.__bases__ = tuple(bases) - - ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotMoveNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotMoveNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotMoveNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotMoveNotSupported_Def.__bases__: - bases = list(ns0.SnapshotMoveNotSupported_Def.__bases__) - bases.insert(0, ns0.SnapshotCopyNotSupported_Def) - ns0.SnapshotMoveNotSupported_Def.__bases__ = tuple(bases) - - ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotMoveToNonHomeNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotMoveToNonHomeNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotMoveToNonHomeNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotMoveToNonHomeNotSupported_Def.__bases__: - bases = list(ns0.SnapshotMoveToNonHomeNotSupported_Def.__bases__) - bases.insert(0, ns0.SnapshotCopyNotSupported_Def) - ns0.SnapshotMoveToNonHomeNotSupported_Def.__bases__ = tuple(bases) - - ns0.SnapshotCopyNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotNoChange_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotNoChange") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotNoChange_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.SnapshotNoChange_Def.__bases__: - bases = list(ns0.SnapshotNoChange_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.SnapshotNoChange_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SnapshotRevertIssue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SnapshotRevertIssue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SnapshotRevertIssue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"snapshotName"), aname="_snapshotName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Event",lazy=True)(pname=(ns,"event"), aname="_event", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"errors"), aname="_errors", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.SnapshotRevertIssue_Def.__bases__: - bases = list(ns0.SnapshotRevertIssue_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.SnapshotRevertIssue_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class StorageVMotionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "StorageVMotionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.StorageVMotionNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFeatureNotSupported_Def not in ns0.StorageVMotionNotSupported_Def.__bases__: - bases = list(ns0.StorageVMotionNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFeatureNotSupported_Def) - ns0.StorageVMotionNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SuspendedRelocateNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SuspendedRelocateNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SuspendedRelocateNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.SuspendedRelocateNotSupported_Def.__bases__: - bases = list(ns0.SuspendedRelocateNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.SuspendedRelocateNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SwapDatastoreNotWritableOnHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SwapDatastoreNotWritableOnHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SwapDatastoreNotWritableOnHost_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreNotWritableOnHost_Def not in ns0.SwapDatastoreNotWritableOnHost_Def.__bases__: - bases = list(ns0.SwapDatastoreNotWritableOnHost_Def.__bases__) - bases.insert(0, ns0.DatastoreNotWritableOnHost_Def) - ns0.SwapDatastoreNotWritableOnHost_Def.__bases__ = tuple(bases) - - ns0.DatastoreNotWritableOnHost_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SwapDatastoreUnset_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SwapDatastoreUnset") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SwapDatastoreUnset_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.SwapDatastoreUnset_Def.__bases__: - bases = list(ns0.SwapDatastoreUnset_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.SwapDatastoreUnset_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SwapPlacementOverrideNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SwapPlacementOverrideNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SwapPlacementOverrideNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidVmConfig_Def not in ns0.SwapPlacementOverrideNotSupported_Def.__bases__: - bases = list(ns0.SwapPlacementOverrideNotSupported_Def.__bases__) - bases.insert(0, ns0.InvalidVmConfig_Def) - ns0.SwapPlacementOverrideNotSupported_Def.__bases__ = tuple(bases) - - ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class SwitchNotInUpgradeMode_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SwitchNotInUpgradeMode") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SwitchNotInUpgradeMode_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsFault_Def not in ns0.SwitchNotInUpgradeMode_Def.__bases__: - bases = list(ns0.SwitchNotInUpgradeMode_Def.__bases__) - bases.insert(0, ns0.DvsFault_Def) - ns0.SwitchNotInUpgradeMode_Def.__bases__ = tuple(bases) - - ns0.DvsFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TaskInProgress_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskInProgress") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskInProgress_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"task"), aname="_task", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.TaskInProgress_Def.__bases__: - bases = list(ns0.TaskInProgress_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.TaskInProgress_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class Timedout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "Timedout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.Timedout_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.Timedout_Def.__bases__: - bases = list(ns0.Timedout_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.Timedout_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TooManyConsecutiveOverrides_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TooManyConsecutiveOverrides") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TooManyConsecutiveOverrides_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.TooManyConsecutiveOverrides_Def.__bases__: - bases = list(ns0.TooManyConsecutiveOverrides_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.TooManyConsecutiveOverrides_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TooManyDevices_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TooManyDevices") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TooManyDevices_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidVmConfig_Def not in ns0.TooManyDevices_Def.__bases__: - bases = list(ns0.TooManyDevices_Def.__bases__) - bases.insert(0, ns0.InvalidVmConfig_Def) - ns0.TooManyDevices_Def.__bases__ = tuple(bases) - - ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TooManyDisksOnLegacyHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TooManyDisksOnLegacyHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TooManyDisksOnLegacyHost_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"diskCount"), aname="_diskCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"timeoutDanger"), aname="_timeoutDanger", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.TooManyDisksOnLegacyHost_Def.__bases__: - bases = list(ns0.TooManyDisksOnLegacyHost_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.TooManyDisksOnLegacyHost_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TooManyHosts_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TooManyHosts") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TooManyHosts_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectFault_Def not in ns0.TooManyHosts_Def.__bases__: - bases = list(ns0.TooManyHosts_Def.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.TooManyHosts_Def.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TooManySnapshotLevels_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TooManySnapshotLevels") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TooManySnapshotLevels_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.SnapshotFault_Def not in ns0.TooManySnapshotLevels_Def.__bases__: - bases = list(ns0.TooManySnapshotLevels_Def.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.TooManySnapshotLevels_Def.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ToolsAlreadyUpgraded_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsAlreadyUpgraded") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsAlreadyUpgraded_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsAlreadyUpgraded_Def.__bases__: - bases = list(ns0.ToolsAlreadyUpgraded_Def.__bases__) - bases.insert(0, ns0.VmToolsUpgradeFault_Def) - ns0.ToolsAlreadyUpgraded_Def.__bases__ = tuple(bases) - - ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ToolsAutoUpgradeNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsAutoUpgradeNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsAutoUpgradeNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsAutoUpgradeNotSupported_Def.__bases__: - bases = list(ns0.ToolsAutoUpgradeNotSupported_Def.__bases__) - bases.insert(0, ns0.VmToolsUpgradeFault_Def) - ns0.ToolsAutoUpgradeNotSupported_Def.__bases__ = tuple(bases) - - ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ToolsImageNotAvailable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsImageNotAvailable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsImageNotAvailable_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsImageNotAvailable_Def.__bases__: - bases = list(ns0.ToolsImageNotAvailable_Def.__bases__) - bases.insert(0, ns0.VmToolsUpgradeFault_Def) - ns0.ToolsImageNotAvailable_Def.__bases__ = tuple(bases) - - ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ToolsImageSignatureCheckFailed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsImageSignatureCheckFailed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsImageSignatureCheckFailed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsImageSignatureCheckFailed_Def.__bases__: - bases = list(ns0.ToolsImageSignatureCheckFailed_Def.__bases__) - bases.insert(0, ns0.VmToolsUpgradeFault_Def) - ns0.ToolsImageSignatureCheckFailed_Def.__bases__ = tuple(bases) - - ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ToolsInstallationInProgress_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsInstallationInProgress") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsInstallationInProgress_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.ToolsInstallationInProgress_Def.__bases__: - bases = list(ns0.ToolsInstallationInProgress_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.ToolsInstallationInProgress_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ToolsUnavailable_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsUnavailable") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsUnavailable_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.ToolsUnavailable_Def.__bases__: - bases = list(ns0.ToolsUnavailable_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.ToolsUnavailable_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ToolsUpgradeCancelled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsUpgradeCancelled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsUpgradeCancelled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmToolsUpgradeFault_Def not in ns0.ToolsUpgradeCancelled_Def.__bases__: - bases = list(ns0.ToolsUpgradeCancelled_Def.__bases__) - bases.insert(0, ns0.VmToolsUpgradeFault_Def) - ns0.ToolsUpgradeCancelled_Def.__bases__ = tuple(bases) - - ns0.VmToolsUpgradeFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UncommittedUndoableDisk_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UncommittedUndoableDisk") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UncommittedUndoableDisk_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.UncommittedUndoableDisk_Def.__bases__: - bases = list(ns0.UncommittedUndoableDisk_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.UncommittedUndoableDisk_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnconfiguredPropertyValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnconfiguredPropertyValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnconfiguredPropertyValue_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidPropertyValue_Def not in ns0.UnconfiguredPropertyValue_Def.__bases__: - bases = list(ns0.UnconfiguredPropertyValue_Def.__bases__) - bases.insert(0, ns0.InvalidPropertyValue_Def) - ns0.UnconfiguredPropertyValue_Def.__bases__ = tuple(bases) - - ns0.InvalidPropertyValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UncustomizableGuest_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UncustomizableGuest") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UncustomizableGuest_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"uncustomizableGuestOS"), aname="_uncustomizableGuestOS", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.UncustomizableGuest_Def.__bases__: - bases = list(ns0.UncustomizableGuest_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.UncustomizableGuest_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnexpectedCustomizationFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnexpectedCustomizationFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnexpectedCustomizationFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.UnexpectedCustomizationFault_Def.__bases__: - bases = list(ns0.UnexpectedCustomizationFault_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.UnexpectedCustomizationFault_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnrecognizedHost_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnrecognizedHost") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnrecognizedHost_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.UnrecognizedHost_Def.__bases__: - bases = list(ns0.UnrecognizedHost_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.UnrecognizedHost_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnsharedSwapVMotionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnsharedSwapVMotionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnsharedSwapVMotionNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFeatureNotSupported_Def not in ns0.UnsharedSwapVMotionNotSupported_Def.__bases__: - bases = list(ns0.UnsharedSwapVMotionNotSupported_Def.__bases__) - bases.insert(0, ns0.MigrationFeatureNotSupported_Def) - ns0.UnsharedSwapVMotionNotSupported_Def.__bases__ = tuple(bases) - - ns0.MigrationFeatureNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnsupportedDatastore_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnsupportedDatastore") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnsupportedDatastore_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.UnsupportedDatastore_Def.__bases__: - bases = list(ns0.UnsupportedDatastore_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.UnsupportedDatastore_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnsupportedGuest_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnsupportedGuest") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnsupportedGuest_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"unsupportedGuestOS"), aname="_unsupportedGuestOS", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidVmConfig_Def not in ns0.UnsupportedGuest_Def.__bases__: - bases = list(ns0.UnsupportedGuest_Def.__bases__) - bases.insert(0, ns0.InvalidVmConfig_Def) - ns0.UnsupportedGuest_Def.__bases__ = tuple(bases) - - ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnsupportedVimApiVersion_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnsupportedVimApiVersion") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnsupportedVimApiVersion_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.UnsupportedVimApiVersion_Def.__bases__: - bases = list(ns0.UnsupportedVimApiVersion_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.UnsupportedVimApiVersion_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnsupportedVmxLocation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnsupportedVmxLocation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnsupportedVmxLocation_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.UnsupportedVmxLocation_Def.__bases__: - bases = list(ns0.UnsupportedVmxLocation_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.UnsupportedVmxLocation_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UnusedVirtualDiskBlocksNotScrubbed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UnusedVirtualDiskBlocksNotScrubbed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceBackingNotSupported_Def not in ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__bases__: - bases = list(ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__bases__) - bases.insert(0, ns0.DeviceBackingNotSupported_Def) - ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__bases__ = tuple(bases) - - ns0.DeviceBackingNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserNotFound_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserNotFound") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserNotFound_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unresolved"), aname="_unresolved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.UserNotFound_Def.__bases__: - bases = list(ns0.UserNotFound_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.UserNotFound_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppConfigFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppConfigFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppConfigFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.VAppConfigFault_Def.__bases__: - bases = list(ns0.VAppConfigFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.VAppConfigFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppNotRunning_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppNotRunning") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppNotRunning_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.VAppNotRunning_Def.__bases__: - bases = list(ns0.VAppNotRunning_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.VAppNotRunning_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppPropertyFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppPropertyFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppPropertyFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.VAppPropertyFault_Def.__bases__: - bases = list(ns0.VAppPropertyFault_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.VAppPropertyFault_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppTaskInProgress_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppTaskInProgress") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppTaskInProgress_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskInProgress_Def not in ns0.VAppTaskInProgress_Def.__bases__: - bases = list(ns0.VAppTaskInProgress_Def.__bases__) - bases.insert(0, ns0.TaskInProgress_Def) - ns0.VAppTaskInProgress_Def.__bases__ = tuple(bases) - - ns0.TaskInProgress_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMINotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMINotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMINotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.VMINotSupported_Def.__bases__: - bases = list(ns0.VMINotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.VMINotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMOnConflictDVPort_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMOnConflictDVPort") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMOnConflictDVPort_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessNetwork_Def not in ns0.VMOnConflictDVPort_Def.__bases__: - bases = list(ns0.VMOnConflictDVPort_Def.__bases__) - bases.insert(0, ns0.CannotAccessNetwork_Def) - ns0.VMOnConflictDVPort_Def.__bases__ = tuple(bases) - - ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMOnVirtualIntranet_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMOnVirtualIntranet") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMOnVirtualIntranet_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CannotAccessNetwork_Def not in ns0.VMOnVirtualIntranet_Def.__bases__: - bases = list(ns0.VMOnVirtualIntranet_Def.__bases__) - bases.insert(0, ns0.CannotAccessNetwork_Def) - ns0.VMOnVirtualIntranet_Def.__bases__ = tuple(bases) - - ns0.CannotAccessNetwork_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionInterfaceIssue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionInterfaceIssue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionInterfaceIssue_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"atSourceHost"), aname="_atSourceHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"failedHost"), aname="_failedHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"failedHostEntity"), aname="_failedHostEntity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.VMotionInterfaceIssue_Def.__bases__: - bases = list(ns0.VMotionInterfaceIssue_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.VMotionInterfaceIssue_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionLinkCapacityLow_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionLinkCapacityLow") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionLinkCapacityLow_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionLinkCapacityLow_Def.__bases__: - bases = list(ns0.VMotionLinkCapacityLow_Def.__bases__) - bases.insert(0, ns0.VMotionInterfaceIssue_Def) - ns0.VMotionLinkCapacityLow_Def.__bases__ = tuple(bases) - - ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionLinkDown_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionLinkDown") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionLinkDown_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionLinkDown_Def.__bases__: - bases = list(ns0.VMotionLinkDown_Def.__bases__) - bases.insert(0, ns0.VMotionInterfaceIssue_Def) - ns0.VMotionLinkDown_Def.__bases__ = tuple(bases) - - ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionNotConfigured_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionNotConfigured") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionNotConfigured_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionNotConfigured_Def.__bases__: - bases = list(ns0.VMotionNotConfigured_Def.__bases__) - bases.insert(0, ns0.VMotionInterfaceIssue_Def) - ns0.VMotionNotConfigured_Def.__bases__ = tuple(bases) - - ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionNotLicensed_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionNotLicensed") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionNotLicensed_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionNotLicensed_Def.__bases__: - bases = list(ns0.VMotionNotLicensed_Def.__bases__) - bases.insert(0, ns0.VMotionInterfaceIssue_Def) - ns0.VMotionNotLicensed_Def.__bases__ = tuple(bases) - - ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionNotSupported_Def.__bases__: - bases = list(ns0.VMotionNotSupported_Def.__bases__) - bases.insert(0, ns0.VMotionInterfaceIssue_Def) - ns0.VMotionNotSupported_Def.__bases__ = tuple(bases) - - ns0.VMotionInterfaceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VMotionProtocolIncompatible_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VMotionProtocolIncompatible") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VMotionProtocolIncompatible_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.VMotionProtocolIncompatible_Def.__bases__: - bases = list(ns0.VMotionProtocolIncompatible_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.VMotionProtocolIncompatible_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VimFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VimFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VimFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MethodFault_Def not in ns0.VimFault_Def.__bases__: - bases = list(ns0.VimFault_Def.__bases__) - bases.insert(0, ns0.MethodFault_Def) - ns0.VimFault_Def.__bases__ = tuple(bases) - - ns0.MethodFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskBlocksNotFullyProvisioned_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskBlocksNotFullyProvisioned") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskBlocksNotFullyProvisioned_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceBackingNotSupported_Def not in ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__bases__: - bases = list(ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__bases__) - bases.insert(0, ns0.DeviceBackingNotSupported_Def) - ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__bases__ = tuple(bases) - - ns0.DeviceBackingNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DeviceNotSupported_Def not in ns0.VirtualEthernetCardNotSupported_Def.__bases__: - bases = list(ns0.VirtualEthernetCardNotSupported_Def.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.VirtualEthernetCardNotSupported_Def.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualHardwareCompatibilityIssue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualHardwareCompatibilityIssue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualHardwareCompatibilityIssue_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.VirtualHardwareCompatibilityIssue_Def.__bases__: - bases = list(ns0.VirtualHardwareCompatibilityIssue_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.VirtualHardwareCompatibilityIssue_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualHardwareVersionNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualHardwareVersionNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualHardwareVersionNotSupported_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.VirtualHardwareVersionNotSupported_Def.__bases__: - bases = list(ns0.VirtualHardwareVersionNotSupported_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.VirtualHardwareVersionNotSupported_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmAlreadyExistsInDatacenter_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmAlreadyExistsInDatacenter") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmAlreadyExistsInDatacenter_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostname"), aname="_hostname", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidFolder_Def not in ns0.VmAlreadyExistsInDatacenter_Def.__bases__: - bases = list(ns0.VmAlreadyExistsInDatacenter_Def.__bases__) - bases.insert(0, ns0.InvalidFolder_Def) - ns0.VmAlreadyExistsInDatacenter_Def.__bases__ = tuple(bases) - - ns0.InvalidFolder_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.VmConfigFault_Def.__bases__: - bases = list(ns0.VmConfigFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.VmConfigFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigIncompatibleForFaultTolerance_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigIncompatibleForFaultTolerance") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigIncompatibleForFaultTolerance_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.VmConfigIncompatibleForFaultTolerance_Def.__bases__: - bases = list(ns0.VmConfigIncompatibleForFaultTolerance_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.VmConfigIncompatibleForFaultTolerance_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigIncompatibleForRecordReplay_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigIncompatibleForRecordReplay") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigIncompatibleForRecordReplay_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFault_Def not in ns0.VmConfigIncompatibleForRecordReplay_Def.__bases__: - bases = list(ns0.VmConfigIncompatibleForRecordReplay_Def.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.VmConfigIncompatibleForRecordReplay_Def.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFaultToleranceConfigIssueReasonForIssue_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VmFaultToleranceConfigIssueReasonForIssue") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VmFaultToleranceConfigIssue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFaultToleranceConfigIssue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFaultToleranceConfigIssue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"entityName"), aname="_entityName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceConfigIssue_Def.__bases__: - bases = list(ns0.VmFaultToleranceConfigIssue_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.VmFaultToleranceConfigIssue_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFaultToleranceInvalidFileBackingDeviceType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VmFaultToleranceInvalidFileBackingDeviceType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VmFaultToleranceInvalidFileBacking_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFaultToleranceInvalidFileBacking") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFaultToleranceInvalidFileBacking_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"backingType"), aname="_backingType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backingFilename"), aname="_backingFilename", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceInvalidFileBacking_Def.__bases__: - bases = list(ns0.VmFaultToleranceInvalidFileBacking_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.VmFaultToleranceInvalidFileBacking_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFaultToleranceIssue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFaultToleranceIssue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFaultToleranceIssue_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.VmFaultToleranceIssue_Def.__bases__: - bases = list(ns0.VmFaultToleranceIssue_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.VmFaultToleranceIssue_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmFaultToleranceOpIssuesList_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmFaultToleranceOpIssuesList") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmFaultToleranceOpIssuesList_Def.schema - TClist = [GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"errors"), aname="_errors", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warnings"), aname="_warnings", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceOpIssuesList_Def.__bases__: - bases = list(ns0.VmFaultToleranceOpIssuesList_Def.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.VmFaultToleranceOpIssuesList_Def.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmLimitLicense_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmLimitLicense") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmLimitLicense_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"limit"), aname="_limit", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.NotEnoughLicenses_Def not in ns0.VmLimitLicense_Def.__bases__: - bases = list(ns0.VmLimitLicense_Def.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.VmLimitLicense_Def.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmPowerOnDisabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmPowerOnDisabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmPowerOnDisabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidState_Def not in ns0.VmPowerOnDisabled_Def.__bases__: - bases = list(ns0.VmPowerOnDisabled_Def.__bases__) - bases.insert(0, ns0.InvalidState_Def) - ns0.VmPowerOnDisabled_Def.__bases__ = tuple(bases) - - ns0.InvalidState_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmToolsUpgradeFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmToolsUpgradeFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmToolsUpgradeFault_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.VmToolsUpgradeFault_Def.__bases__: - bases = list(ns0.VmToolsUpgradeFault_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.VmToolsUpgradeFault_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmValidateMaxDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmValidateMaxDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmValidateMaxDevice_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"count"), aname="_count", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VimFault_Def not in ns0.VmValidateMaxDevice_Def.__bases__: - bases = list(ns0.VmValidateMaxDevice_Def.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.VmValidateMaxDevice_Def.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmWwnConflict_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmWwnConflict") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmWwnConflict_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"wwn"), aname="_wwn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.InvalidVmConfig_Def not in ns0.VmWwnConflict_Def.__bases__: - bases = list(ns0.VmWwnConflict_Def.__bases__) - bases.insert(0, ns0.InvalidVmConfig_Def) - ns0.VmWwnConflict_Def.__bases__ = tuple(bases) - - ns0.InvalidVmConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsAlreadyMounted_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsAlreadyMounted") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsAlreadyMounted_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsMountFault_Def not in ns0.VmfsAlreadyMounted_Def.__bases__: - bases = list(ns0.VmfsAlreadyMounted_Def.__bases__) - bases.insert(0, ns0.VmfsMountFault_Def) - ns0.VmfsAlreadyMounted_Def.__bases__ = tuple(bases) - - ns0.VmfsMountFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsAmbiguousMount_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsAmbiguousMount") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsAmbiguousMount_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsMountFault_Def not in ns0.VmfsAmbiguousMount_Def.__bases__: - bases = list(ns0.VmfsAmbiguousMount_Def.__bases__) - bases.insert(0, ns0.VmfsMountFault_Def) - ns0.VmfsAmbiguousMount_Def.__bases__ = tuple(bases) - - ns0.VmfsMountFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsMountFault_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsMountFault") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsMountFault_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConfigFault_Def not in ns0.VmfsMountFault_Def.__bases__: - bases = list(ns0.VmfsMountFault_Def.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.VmfsMountFault_Def.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmotionInterfaceNotEnabled_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmotionInterfaceNotEnabled") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmotionInterfaceNotEnabled_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostPowerOpFailed_Def not in ns0.VmotionInterfaceNotEnabled_Def.__bases__: - bases = list(ns0.VmotionInterfaceNotEnabled_Def.__bases__) - bases.insert(0, ns0.HostPowerOpFailed_Def) - ns0.VmotionInterfaceNotEnabled_Def.__bases__ = tuple(bases) - - ns0.HostPowerOpFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VolumeEditorError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VolumeEditorError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VolumeEditorError_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationFault_Def not in ns0.VolumeEditorError_Def.__bases__: - bases = list(ns0.VolumeEditorError_Def.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.VolumeEditorError_Def.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class WakeOnLanNotSupported_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "WakeOnLanNotSupported") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.WakeOnLanNotSupported_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.WakeOnLanNotSupported_Def.__bases__: - bases = list(ns0.WakeOnLanNotSupported_Def.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.WakeOnLanNotSupported_Def.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class WakeOnLanNotSupportedByVmotionNIC_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "WakeOnLanNotSupportedByVmotionNIC") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.WakeOnLanNotSupportedByVmotionNIC_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostPowerOpFailed_Def not in ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__bases__: - bases = list(ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__bases__) - bases.insert(0, ns0.HostPowerOpFailed_Def) - ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__bases__ = tuple(bases) - - ns0.HostPowerOpFailed_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class WillModifyConfigCpuRequirements_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "WillModifyConfigCpuRequirements") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.WillModifyConfigCpuRequirements_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MigrationFault_Def not in ns0.WillModifyConfigCpuRequirements_Def.__bases__: - bases = list(ns0.WillModifyConfigCpuRequirements_Def.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.WillModifyConfigCpuRequirements_Def.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AutoStartAction_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AutoStartAction") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class AutoStartDefaults_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AutoStartDefaults") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AutoStartDefaults_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startDelay"), aname="_startDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"stopDelay"), aname="_stopDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"waitForHeartbeat"), aname="_waitForHeartbeat", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"stopAction"), aname="_stopAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AutoStartDefaults_Def.__bases__: - bases = list(ns0.AutoStartDefaults_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AutoStartDefaults_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AutoStartWaitHeartbeatSetting_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AutoStartWaitHeartbeatSetting") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class AutoStartPowerInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AutoStartPowerInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AutoStartPowerInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startOrder"), aname="_startOrder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startDelay"), aname="_startDelay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AutoStartWaitHeartbeatSetting",lazy=True)(pname=(ns,"waitForHeartbeat"), aname="_waitForHeartbeat", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"startAction"), aname="_startAction", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"stopDelay"), aname="_stopDelay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"stopAction"), aname="_stopAction", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.AutoStartPowerInfo_Def.__bases__: - bases = list(ns0.AutoStartPowerInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.AutoStartPowerInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfAutoStartPowerInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAutoStartPowerInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAutoStartPowerInfo_Def.schema - TClist = [GTD("urn:vim25","AutoStartPowerInfo",lazy=True)(pname=(ns,"AutoStartPowerInfo"), aname="_AutoStartPowerInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._AutoStartPowerInfo = [] - return - Holder.__name__ = "ArrayOfAutoStartPowerInfo_Holder" - self.pyclass = Holder - - class HostAutoStartManagerConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostAutoStartManagerConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostAutoStartManagerConfig_Def.schema - TClist = [GTD("urn:vim25","AutoStartDefaults",lazy=True)(pname=(ns,"defaults"), aname="_defaults", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AutoStartPowerInfo",lazy=True)(pname=(ns,"powerInfo"), aname="_powerInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostAutoStartManagerConfig_Def.__bases__: - bases = list(ns0.HostAutoStartManagerConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostAutoStartManagerConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReconfigureAutostartRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureAutostartRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureAutostartRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAutoStartManagerConfig",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "ReconfigureAutostartRequestType_Holder" - self.pyclass = Holder - - class AutoStartPowerOnRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AutoStartPowerOnRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AutoStartPowerOnRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "AutoStartPowerOnRequestType_Holder" - self.pyclass = Holder - - class AutoStartPowerOffRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AutoStartPowerOffRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AutoStartPowerOffRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "AutoStartPowerOffRequestType_Holder" - self.pyclass = Holder - - class HostBootDeviceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostBootDeviceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostBootDeviceInfo_Def.schema - TClist = [GTD("urn:vim25","HostBootDevice",lazy=True)(pname=(ns,"bootDevices"), aname="_bootDevices", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"currentBootDeviceKey"), aname="_currentBootDeviceKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostBootDeviceInfo_Def.__bases__: - bases = list(ns0.HostBootDeviceInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostBootDeviceInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostBootDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostBootDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostBootDevice_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostBootDevice_Def.__bases__: - bases = list(ns0.HostBootDevice_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostBootDevice_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostBootDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostBootDevice") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostBootDevice_Def.schema - TClist = [GTD("urn:vim25","HostBootDevice",lazy=True)(pname=(ns,"HostBootDevice"), aname="_HostBootDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostBootDevice = [] - return - Holder.__name__ = "ArrayOfHostBootDevice_Holder" - self.pyclass = Holder - - class QueryBootDevicesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryBootDevicesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryBootDevicesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryBootDevicesRequestType_Holder" - self.pyclass = Holder - - class UpdateBootDeviceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateBootDeviceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateBootDeviceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._key = None - return - Holder.__name__ = "UpdateBootDeviceRequestType_Holder" - self.pyclass = Holder - - class HostReplayUnsupportedReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostReplayUnsupportedReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostCapability_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCapability") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCapability_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"recursiveResourcePoolsSupported"), aname="_recursiveResourcePoolsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuMemoryResourceConfigurationSupported"), aname="_cpuMemoryResourceConfigurationSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rebootSupported"), aname="_rebootSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shutdownSupported"), aname="_shutdownSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmotionSupported"), aname="_vmotionSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"standbySupported"), aname="_standbySupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipmiSupported"), aname="_ipmiSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSupportedVMs"), aname="_maxSupportedVMs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxRunningVMs"), aname="_maxRunningVMs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSupportedVcpus"), aname="_maxSupportedVcpus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"datastorePrincipalSupported"), aname="_datastorePrincipalSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sanSupported"), aname="_sanSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"nfsSupported"), aname="_nfsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"iscsiSupported"), aname="_iscsiSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vlanTaggingSupported"), aname="_vlanTaggingSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"nicTeamingSupported"), aname="_nicTeamingSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"highGuestMemSupported"), aname="_highGuestMemSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"maintenanceModeSupported"), aname="_maintenanceModeSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suspendedRelocateSupported"), aname="_suspendedRelocateSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"restrictedSnapshotRelocateSupported"), aname="_restrictedSnapshotRelocateSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"perVmSwapFiles"), aname="_perVmSwapFiles", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"localSwapDatastoreSupported"), aname="_localSwapDatastoreSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unsharedSwapVMotionSupported"), aname="_unsharedSwapVMotionSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"backgroundSnapshotsSupported"), aname="_backgroundSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"preAssignedPCIUnitNumbersSupported"), aname="_preAssignedPCIUnitNumbersSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"screenshotSupported"), aname="_screenshotSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"scaledScreenshotSupported"), aname="_scaledScreenshotSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"storageVMotionSupported"), aname="_storageVMotionSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmotionWithStorageVMotionSupported"), aname="_vmotionWithStorageVMotionSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recordReplaySupported"), aname="_recordReplaySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ftSupported"), aname="_ftSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"replayUnsupportedReason"), aname="_replayUnsupportedReason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"loginBySSLThumbprintSupported"), aname="_loginBySSLThumbprintSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cloneFromSnapshotSupported"), aname="_cloneFromSnapshotSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deltaDiskBackingsSupported"), aname="_deltaDiskBackingsSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"perVMNetworkTrafficShapingSupported"), aname="_perVMNetworkTrafficShapingSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tpmSupported"), aname="_tpmSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"supportedCpuFeature"), aname="_supportedCpuFeature", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"virtualExecUsageSupported"), aname="_virtualExecUsageSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostCapability_Def.__bases__: - bases = list(ns0.HostCapability_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostCapability_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigChangeMode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostConfigChangeMode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostConfigChangeOperation_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostConfigChangeOperation") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostConfigChange_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigChange") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigChange_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConfigChange_Def.__bases__: - bases = list(ns0.HostConfigChange_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConfigChange_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AboutInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHyperThreadScheduleInfo",lazy=True)(pname=(ns,"hyperThread"), aname="_hyperThread", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ServiceConsoleReservationInfo",lazy=True)(pname=(ns,"consoleReservation"), aname="_consoleReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMemoryReservationInfo",lazy=True)(pname=(ns,"virtualMachineReservation"), aname="_virtualMachineReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostStorageDeviceInfo",lazy=True)(pname=(ns,"storageDevice"), aname="_storageDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathStateInfo",lazy=True)(pname=(ns,"multipathState"), aname="_multipathState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFileSystemVolumeInfo",lazy=True)(pname=(ns,"fileSystemVolume"), aname="_fileSystemVolume", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVMotionInfo",lazy=True)(pname=(ns,"vmotion"), aname="_vmotion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicManagerInfo",lazy=True)(pname=(ns,"virtualNicManagerInfo"), aname="_virtualNicManagerInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetCapabilities",lazy=True)(pname=(ns,"capabilities"), aname="_capabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreSystemCapabilities",lazy=True)(pname=(ns,"datastoreCapabilities"), aname="_datastoreCapabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetOffloadCapabilities",lazy=True)(pname=(ns,"offloadCapabilities"), aname="_offloadCapabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostServiceInfo",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallInfo",lazy=True)(pname=(ns,"firewall"), aname="_firewall", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAutoStartManagerConfig",lazy=True)(pname=(ns,"autoStart"), aname="_autoStart", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiagnosticPartition",lazy=True)(pname=(ns,"activeDiagnosticPartition"), aname="_activeDiagnosticPartition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"optionDef"), aname="_optionDef", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePrincipal"), aname="_datastorePrincipal", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"localSwapDatastore"), aname="_localSwapDatastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"systemResources"), aname="_systemResources", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDateTimeInfo",lazy=True)(pname=(ns,"dateTimeInfo"), aname="_dateTimeInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFlagInfo",lazy=True)(pname=(ns,"flags"), aname="_flags", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"adminDisabled"), aname="_adminDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpmiInfo",lazy=True)(pname=(ns,"ipmi"), aname="_ipmi", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSslThumbprintInfo",lazy=True)(pname=(ns,"sslThumbprintInfo"), aname="_sslThumbprintInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPciPassthruInfo",lazy=True)(pname=(ns,"pciPassthruInfo"), aname="_pciPassthruInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConfigInfo_Def.__bases__: - bases = list(ns0.HostConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigManager_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigManager") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigManager_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"cpuScheduler"), aname="_cpuScheduler", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastoreSystem"), aname="_datastoreSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"memoryManager"), aname="_memoryManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"storageSystem"), aname="_storageSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"networkSystem"), aname="_networkSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmotionSystem"), aname="_vmotionSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"virtualNicManager"), aname="_virtualNicManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"serviceSystem"), aname="_serviceSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"firewallSystem"), aname="_firewallSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"advancedOption"), aname="_advancedOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"diagnosticSystem"), aname="_diagnosticSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"autoStartManager"), aname="_autoStartManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snmpSystem"), aname="_snmpSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"dateTimeSystem"), aname="_dateTimeSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"patchManager"), aname="_patchManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"bootDeviceSystem"), aname="_bootDeviceSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"firmwareSystem"), aname="_firmwareSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"healthStatusSystem"), aname="_healthStatusSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pciPassthruSystem"), aname="_pciPassthruSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"licenseManager"), aname="_licenseManager", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"kernelModuleSystem"), aname="_kernelModuleSystem", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConfigManager_Def.__bases__: - bases = list(ns0.HostConfigManager_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConfigManager_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigSpec_Def.schema - TClist = [GTD("urn:vim25","HostNasVolumeConfig",lazy=True)(pname=(ns,"nasDatastore"), aname="_nasDatastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkConfig",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicManagerNicTypeSelection",lazy=True)(pname=(ns,"nicTypeSelection"), aname="_nicTypeSelection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostServiceConfig",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallConfig",lazy=True)(pname=(ns,"firewall"), aname="_firewall", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePrincipal"), aname="_datastorePrincipal", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePrincipalPasswd"), aname="_datastorePrincipalPasswd", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDateTimeConfig",lazy=True)(pname=(ns,"datetime"), aname="_datetime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostStorageDeviceInfo",lazy=True)(pname=(ns,"storageDevice"), aname="_storageDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostLicenseSpec",lazy=True)(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSecuritySpec",lazy=True)(pname=(ns,"security"), aname="_security", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"userAccount"), aname="_userAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"usergroupAccount"), aname="_usergroupAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMemorySpec",lazy=True)(pname=(ns,"memory"), aname="_memory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConfigSpec_Def.__bases__: - bases = list(ns0.HostConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConnectInfoNetworkInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConnectInfoNetworkInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConnectInfoNetworkInfo_Def.schema - TClist = [GTD("urn:vim25","NetworkSummary",lazy=True)(pname=(ns,"summary"), aname="_summary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConnectInfoNetworkInfo_Def.__bases__: - bases = list(ns0.HostConnectInfoNetworkInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConnectInfoNetworkInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostConnectInfoNetworkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostConnectInfoNetworkInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostConnectInfoNetworkInfo_Def.schema - TClist = [GTD("urn:vim25","HostConnectInfoNetworkInfo",lazy=True)(pname=(ns,"HostConnectInfoNetworkInfo"), aname="_HostConnectInfoNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostConnectInfoNetworkInfo = [] - return - Holder.__name__ = "ArrayOfHostConnectInfoNetworkInfo_Holder" - self.pyclass = Holder - - class HostNewNetworkConnectInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNewNetworkConnectInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNewNetworkConnectInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostConnectInfoNetworkInfo_Def not in ns0.HostNewNetworkConnectInfo_Def.__bases__: - bases = list(ns0.HostNewNetworkConnectInfo_Def.__bases__) - bases.insert(0, ns0.HostConnectInfoNetworkInfo_Def) - ns0.HostNewNetworkConnectInfo_Def.__bases__ = tuple(bases) - - ns0.HostConnectInfoNetworkInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDatastoreConnectInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDatastoreConnectInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDatastoreConnectInfo_Def.schema - TClist = [GTD("urn:vim25","DatastoreSummary",lazy=True)(pname=(ns,"summary"), aname="_summary", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDatastoreConnectInfo_Def.__bases__: - bases = list(ns0.HostDatastoreConnectInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDatastoreConnectInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDatastoreConnectInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDatastoreConnectInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDatastoreConnectInfo_Def.schema - TClist = [GTD("urn:vim25","HostDatastoreConnectInfo",lazy=True)(pname=(ns,"HostDatastoreConnectInfo"), aname="_HostDatastoreConnectInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDatastoreConnectInfo = [] - return - Holder.__name__ = "ArrayOfHostDatastoreConnectInfo_Holder" - self.pyclass = Holder - - class HostDatastoreExistsConnectInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDatastoreExistsConnectInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDatastoreExistsConnectInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"newDatastoreName"), aname="_newDatastoreName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDatastoreConnectInfo_Def not in ns0.HostDatastoreExistsConnectInfo_Def.__bases__: - bases = list(ns0.HostDatastoreExistsConnectInfo_Def.__bases__) - bases.insert(0, ns0.HostDatastoreConnectInfo_Def) - ns0.HostDatastoreExistsConnectInfo_Def.__bases__ = tuple(bases) - - ns0.HostDatastoreConnectInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDatastoreNameConflictConnectInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDatastoreNameConflictConnectInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDatastoreNameConflictConnectInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"newDatastoreName"), aname="_newDatastoreName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDatastoreConnectInfo_Def not in ns0.HostDatastoreNameConflictConnectInfo_Def.__bases__: - bases = list(ns0.HostDatastoreNameConflictConnectInfo_Def.__bases__) - bases.insert(0, ns0.HostDatastoreConnectInfo_Def) - ns0.HostDatastoreNameConflictConnectInfo_Def.__bases__ = tuple(bases) - - ns0.HostDatastoreConnectInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostLicenseConnectInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostLicenseConnectInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostLicenseConnectInfo_Def.schema - TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"license"), aname="_license", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LicenseManagerEvaluationInfo",lazy=True)(pname=(ns,"evaluation"), aname="_evaluation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostLicenseConnectInfo_Def.__bases__: - bases = list(ns0.HostLicenseConnectInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostLicenseConnectInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConnectInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConnectInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConnectInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"serverIp"), aname="_serverIp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostListSummary",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSummary",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vimAccountNameRequired"), aname="_vimAccountNameRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"clusterSupported"), aname="_clusterSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConnectInfoNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreConnectInfo",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostLicenseConnectInfo",lazy=True)(pname=(ns,"license"), aname="_license", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConnectInfo_Def.__bases__: - bases = list(ns0.HostConnectInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConnectInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConnectSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConnectSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConnectSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmFolder"), aname="_vmFolder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vimAccountName"), aname="_vimAccountName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vimAccountPassword"), aname="_vimAccountPassword", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"managementIp"), aname="_managementIp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConnectSpec_Def.__bases__: - bases = list(ns0.HostConnectSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConnectSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCpuIdInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCpuIdInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCpuIdInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"level"), aname="_level", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eax"), aname="_eax", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ebx"), aname="_ebx", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ecx"), aname="_ecx", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"edx"), aname="_edx", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostCpuIdInfo_Def.__bases__: - bases = list(ns0.HostCpuIdInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostCpuIdInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostCpuIdInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostCpuIdInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostCpuIdInfo_Def.schema - TClist = [GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"HostCpuIdInfo"), aname="_HostCpuIdInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostCpuIdInfo = [] - return - Holder.__name__ = "ArrayOfHostCpuIdInfo_Holder" - self.pyclass = Holder - - class HostHyperThreadScheduleInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostHyperThreadScheduleInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostHyperThreadScheduleInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"available"), aname="_available", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"active"), aname="_active", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostHyperThreadScheduleInfo_Def.__bases__: - bases = list(ns0.HostHyperThreadScheduleInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostHyperThreadScheduleInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class EnableHyperThreadingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EnableHyperThreadingRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.EnableHyperThreadingRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "EnableHyperThreadingRequestType_Holder" - self.pyclass = Holder - - class DisableHyperThreadingRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DisableHyperThreadingRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DisableHyperThreadingRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DisableHyperThreadingRequestType_Holder" - self.pyclass = Holder - - class FileQueryFlags_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileQueryFlags") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileQueryFlags_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"fileType"), aname="_fileType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fileSize"), aname="_fileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"modification"), aname="_modification", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fileOwner"), aname="_fileOwner", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.FileQueryFlags_Def.__bases__: - bases = list(ns0.FileQueryFlags_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.FileQueryFlags_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"fileSize"), aname="_fileSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"modification"), aname="_modification", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"owner"), aname="_owner", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.FileInfo_Def.__bases__: - bases = list(ns0.FileInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.FileInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfFileInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfFileInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfFileInfo_Def.schema - TClist = [GTD("urn:vim25","FileInfo",lazy=True)(pname=(ns,"FileInfo"), aname="_FileInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._FileInfo = [] - return - Holder.__name__ = "ArrayOfFileInfo_Holder" - self.pyclass = Holder - - class FileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.FileQuery_Def.__bases__: - bases = list(ns0.FileQuery_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.FileQuery_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfFileQuery_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfFileQuery") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfFileQuery_Def.schema - TClist = [GTD("urn:vim25","FileQuery",lazy=True)(pname=(ns,"FileQuery"), aname="_FileQuery", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._FileQuery = [] - return - Holder.__name__ = "ArrayOfFileQuery_Holder" - self.pyclass = Holder - - class VmConfigFileQueryFilter_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigFileQueryFilter") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigFileQueryFilter_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"matchConfigVersion"), aname="_matchConfigVersion", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmConfigFileQueryFilter_Def.__bases__: - bases = list(ns0.VmConfigFileQueryFilter_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmConfigFileQueryFilter_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigFileQueryFlags_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigFileQueryFlags") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigFileQueryFlags_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmConfigFileQueryFlags_Def.__bases__: - bases = list(ns0.VmConfigFileQueryFlags_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmConfigFileQueryFlags_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigFileQuery_Def.schema - TClist = [GTD("urn:vim25","VmConfigFileQueryFilter",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmConfigFileQueryFlags",lazy=True)(pname=(ns,"details"), aname="_details", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.VmConfigFileQuery_Def.__bases__: - bases = list(ns0.VmConfigFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.VmConfigFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TemplateConfigFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TemplateConfigFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TemplateConfigFileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFileQuery_Def not in ns0.TemplateConfigFileQuery_Def.__bases__: - bases = list(ns0.TemplateConfigFileQuery_Def.__bases__) - bases.insert(0, ns0.VmConfigFileQuery_Def) - ns0.TemplateConfigFileQuery_Def.__bases__ = tuple(bases) - - ns0.VmConfigFileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDiskFileQueryFilter_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDiskFileQueryFilter") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDiskFileQueryFilter_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskType"), aname="_diskType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"matchHardwareVersion"), aname="_matchHardwareVersion", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thin"), aname="_thin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmDiskFileQueryFilter_Def.__bases__: - bases = list(ns0.VmDiskFileQueryFilter_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmDiskFileQueryFilter_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDiskFileQueryFlags_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDiskFileQueryFlags") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDiskFileQueryFlags_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"diskType"), aname="_diskType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"capacityKb"), aname="_capacityKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hardwareVersion"), aname="_hardwareVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"diskExtents"), aname="_diskExtents", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thin"), aname="_thin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmDiskFileQueryFlags_Def.__bases__: - bases = list(ns0.VmDiskFileQueryFlags_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmDiskFileQueryFlags_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDiskFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDiskFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDiskFileQuery_Def.schema - TClist = [GTD("urn:vim25","VmDiskFileQueryFilter",lazy=True)(pname=(ns,"filter"), aname="_filter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmDiskFileQueryFlags",lazy=True)(pname=(ns,"details"), aname="_details", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.VmDiskFileQuery_Def.__bases__: - bases = list(ns0.VmDiskFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.VmDiskFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FolderFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FolderFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FolderFileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.FolderFileQuery_Def.__bases__: - bases = list(ns0.FolderFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.FolderFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSnapshotFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSnapshotFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSnapshotFileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.VmSnapshotFileQuery_Def.__bases__: - bases = list(ns0.VmSnapshotFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.VmSnapshotFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IsoImageFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IsoImageFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IsoImageFileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.IsoImageFileQuery_Def.__bases__: - bases = list(ns0.IsoImageFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.IsoImageFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FloppyImageFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FloppyImageFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FloppyImageFileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.FloppyImageFileQuery_Def.__bases__: - bases = list(ns0.FloppyImageFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.FloppyImageFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmNvramFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmNvramFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmNvramFileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.VmNvramFileQuery_Def.__bases__: - bases = list(ns0.VmNvramFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.VmNvramFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmLogFileQuery_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmLogFileQuery") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmLogFileQuery_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileQuery_Def not in ns0.VmLogFileQuery_Def.__bases__: - bases = list(ns0.VmLogFileQuery_Def.__bases__) - bases.insert(0, ns0.FileQuery_Def) - ns0.VmLogFileQuery_Def.__bases__ = tuple(bases) - - ns0.FileQuery_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigFileInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"configVersion"), aname="_configVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.VmConfigFileInfo_Def.__bases__: - bases = list(ns0.VmConfigFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.VmConfigFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class TemplateConfigFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TemplateConfigFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TemplateConfigFileInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigFileInfo_Def not in ns0.TemplateConfigFileInfo_Def.__bases__: - bases = list(ns0.TemplateConfigFileInfo_Def.__bases__) - bases.insert(0, ns0.VmConfigFileInfo_Def) - ns0.TemplateConfigFileInfo_Def.__bases__ = tuple(bases) - - ns0.VmConfigFileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmDiskFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmDiskFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmDiskFileInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskType"), aname="_diskType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacityKb"), aname="_capacityKb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hardwareVersion"), aname="_hardwareVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskExtents"), aname="_diskExtents", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thin"), aname="_thin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.VmDiskFileInfo_Def.__bases__: - bases = list(ns0.VmDiskFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.VmDiskFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FolderFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FolderFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FolderFileInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.FolderFileInfo_Def.__bases__: - bases = list(ns0.FolderFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.FolderFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmSnapshotFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmSnapshotFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmSnapshotFileInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.VmSnapshotFileInfo_Def.__bases__: - bases = list(ns0.VmSnapshotFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.VmSnapshotFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IsoImageFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IsoImageFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IsoImageFileInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.IsoImageFileInfo_Def.__bases__: - bases = list(ns0.IsoImageFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.IsoImageFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FloppyImageFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FloppyImageFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FloppyImageFileInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.FloppyImageFileInfo_Def.__bases__: - bases = list(ns0.FloppyImageFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.FloppyImageFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmNvramFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmNvramFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmNvramFileInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.VmNvramFileInfo_Def.__bases__: - bases = list(ns0.VmNvramFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.VmNvramFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmLogFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmLogFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmLogFileInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FileInfo_Def not in ns0.VmLogFileInfo_Def.__bases__: - bases = list(ns0.VmLogFileInfo_Def.__bases__) - bases.insert(0, ns0.FileInfo_Def) - ns0.VmLogFileInfo_Def.__bases__ = tuple(bases) - - ns0.FileInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDatastoreBrowserSearchSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDatastoreBrowserSearchSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDatastoreBrowserSearchSpec_Def.schema - TClist = [GTD("urn:vim25","FileQuery",lazy=True)(pname=(ns,"query"), aname="_query", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FileQueryFlags",lazy=True)(pname=(ns,"details"), aname="_details", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"searchCaseInsensitive"), aname="_searchCaseInsensitive", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"matchPattern"), aname="_matchPattern", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sortFoldersFirst"), aname="_sortFoldersFirst", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDatastoreBrowserSearchSpec_Def.__bases__: - bases = list(ns0.HostDatastoreBrowserSearchSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDatastoreBrowserSearchSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDatastoreBrowserSearchResults_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDatastoreBrowserSearchResults") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDatastoreBrowserSearchResults_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"folderPath"), aname="_folderPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FileInfo",lazy=True)(pname=(ns,"file"), aname="_file", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDatastoreBrowserSearchResults_Def.__bases__: - bases = list(ns0.HostDatastoreBrowserSearchResults_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDatastoreBrowserSearchResults_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDatastoreBrowserSearchResults_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDatastoreBrowserSearchResults") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDatastoreBrowserSearchResults_Def.schema - TClist = [GTD("urn:vim25","HostDatastoreBrowserSearchResults",lazy=True)(pname=(ns,"HostDatastoreBrowserSearchResults"), aname="_HostDatastoreBrowserSearchResults", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDatastoreBrowserSearchResults = [] - return - Holder.__name__ = "ArrayOfHostDatastoreBrowserSearchResults_Holder" - self.pyclass = Holder - - class SearchDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SearchDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SearchDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreBrowserSearchSpec",lazy=True)(pname=(ns,"searchSpec"), aname="_searchSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastorePath = None - self._searchSpec = None - return - Holder.__name__ = "SearchDatastoreRequestType_Holder" - self.pyclass = Holder - - class SearchDatastoreSubFoldersRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SearchDatastoreSubFoldersRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SearchDatastoreSubFoldersRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDatastoreBrowserSearchSpec",lazy=True)(pname=(ns,"searchSpec"), aname="_searchSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastorePath = None - self._searchSpec = None - return - Holder.__name__ = "SearchDatastoreSubFoldersRequestType_Holder" - self.pyclass = Holder - - class DeleteFileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DeleteFileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DeleteFileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"datastorePath"), aname="_datastorePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastorePath = None - return - Holder.__name__ = "DeleteFileRequestType_Holder" - self.pyclass = Holder - - class HostDatastoreSystemCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDatastoreSystemCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDatastoreSystemCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"nfsMountCreationRequired"), aname="_nfsMountCreationRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"nfsMountCreationSupported"), aname="_nfsMountCreationSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"localDatastoreSupported"), aname="_localDatastoreSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmfsExtentExpansionSupported"), aname="_vmfsExtentExpansionSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDatastoreSystemCapabilities_Def.__bases__: - bases = list(ns0.HostDatastoreSystemCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDatastoreSystemCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateLocalSwapDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateLocalSwapDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateLocalSwapDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastore = None - return - Holder.__name__ = "UpdateLocalSwapDatastoreRequestType_Holder" - self.pyclass = Holder - - class QueryAvailableDisksForVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryAvailableDisksForVmfsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryAvailableDisksForVmfsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastore = None - return - Holder.__name__ = "QueryAvailableDisksForVmfsRequestType_Holder" - self.pyclass = Holder - - class QueryVmfsDatastoreCreateOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVmfsDatastoreCreateOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._devicePath = None - return - Holder.__name__ = "QueryVmfsDatastoreCreateOptionsRequestType_Holder" - self.pyclass = Holder - - class CreateVmfsDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateVmfsDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateVmfsDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "CreateVmfsDatastoreRequestType_Holder" - self.pyclass = Holder - - class QueryVmfsDatastoreExtendOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVmfsDatastoreExtendOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suppressExpandCandidates"), aname="_suppressExpandCandidates", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastore = None - self._devicePath = None - self._suppressExpandCandidates = None - return - Holder.__name__ = "QueryVmfsDatastoreExtendOptionsRequestType_Holder" - self.pyclass = Holder - - class QueryVmfsDatastoreExpandOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVmfsDatastoreExpandOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastore = None - return - Holder.__name__ = "QueryVmfsDatastoreExpandOptionsRequestType_Holder" - self.pyclass = Holder - - class ExtendVmfsDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExtendVmfsDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExtendVmfsDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreExtendSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastore = None - self._spec = None - return - Holder.__name__ = "ExtendVmfsDatastoreRequestType_Holder" - self.pyclass = Holder - - class ExpandVmfsDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExpandVmfsDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExpandVmfsDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreExpandSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastore = None - self._spec = None - return - Holder.__name__ = "ExpandVmfsDatastoreRequestType_Holder" - self.pyclass = Holder - - class CreateNasDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateNasDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateNasDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNasVolumeSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "CreateNasDatastoreRequestType_Holder" - self.pyclass = Holder - - class CreateLocalDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateLocalDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateLocalDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._path = None - return - Holder.__name__ = "CreateLocalDatastoreRequestType_Holder" - self.pyclass = Holder - - class RemoveDatastoreRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveDatastoreRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveDatastoreRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._datastore = None - return - Holder.__name__ = "RemoveDatastoreRequestType_Holder" - self.pyclass = Holder - - class ConfigureDatastorePrincipalRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ConfigureDatastorePrincipalRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ConfigureDatastorePrincipalRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._userName = None - self._password = None - return - Holder.__name__ = "ConfigureDatastorePrincipalRequestType_Holder" - self.pyclass = Holder - - class QueryUnresolvedVmfsVolumesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryUnresolvedVmfsVolumesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryUnresolvedVmfsVolumesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryUnresolvedVmfsVolumesRequestType_Holder" - self.pyclass = Holder - - class ResignatureUnresolvedVmfsVolumeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResignatureUnresolvedVmfsVolumeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostUnresolvedVmfsResignatureSpec",lazy=True)(pname=(ns,"resolutionSpec"), aname="_resolutionSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._resolutionSpec = None - return - Holder.__name__ = "ResignatureUnresolvedVmfsVolumeRequestType_Holder" - self.pyclass = Holder - - class VmfsDatastoreInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreInfo_Def.schema - TClist = [GTD("urn:vim25","HostVmfsVolume",lazy=True)(pname=(ns,"vmfs"), aname="_vmfs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreInfo_Def not in ns0.VmfsDatastoreInfo_Def.__bases__: - bases = list(ns0.VmfsDatastoreInfo_Def.__bases__) - bases.insert(0, ns0.DatastoreInfo_Def) - ns0.VmfsDatastoreInfo_Def.__bases__ = tuple(bases) - - ns0.DatastoreInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NasDatastoreInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NasDatastoreInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NasDatastoreInfo_Def.schema - TClist = [GTD("urn:vim25","HostNasVolume",lazy=True)(pname=(ns,"nas"), aname="_nas", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreInfo_Def not in ns0.NasDatastoreInfo_Def.__bases__: - bases = list(ns0.NasDatastoreInfo_Def.__bases__) - bases.insert(0, ns0.DatastoreInfo_Def) - ns0.NasDatastoreInfo_Def.__bases__ = tuple(bases) - - ns0.DatastoreInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LocalDatastoreInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LocalDatastoreInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LocalDatastoreInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DatastoreInfo_Def not in ns0.LocalDatastoreInfo_Def.__bases__: - bases = list(ns0.LocalDatastoreInfo_Def.__bases__) - bases.insert(0, ns0.DatastoreInfo_Def) - ns0.LocalDatastoreInfo_Def.__bases__ = tuple(bases) - - ns0.DatastoreInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskUuid"), aname="_diskUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmfsDatastoreSpec_Def.__bases__: - bases = list(ns0.VmfsDatastoreSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmfsDatastoreSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreCreateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreCreateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreCreateSpec_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVmfsSpec",lazy=True)(pname=(ns,"vmfs"), aname="_vmfs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsDatastoreSpec_Def not in ns0.VmfsDatastoreCreateSpec_Def.__bases__: - bases = list(ns0.VmfsDatastoreCreateSpec_Def.__bases__) - bases.insert(0, ns0.VmfsDatastoreSpec_Def) - ns0.VmfsDatastoreCreateSpec_Def.__bases__ = tuple(bases) - - ns0.VmfsDatastoreSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreExtendSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreExtendSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreExtendSpec_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsDatastoreSpec_Def not in ns0.VmfsDatastoreExtendSpec_Def.__bases__: - bases = list(ns0.VmfsDatastoreExtendSpec_Def.__bases__) - bases.insert(0, ns0.VmfsDatastoreSpec_Def) - ns0.VmfsDatastoreExtendSpec_Def.__bases__ = tuple(bases) - - ns0.VmfsDatastoreSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreExpandSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreExpandSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreExpandSpec_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsDatastoreSpec_Def not in ns0.VmfsDatastoreExpandSpec_Def.__bases__: - bases = list(ns0.VmfsDatastoreExpandSpec_Def.__bases__) - bases.insert(0, ns0.VmfsDatastoreSpec_Def) - ns0.VmfsDatastoreExpandSpec_Def.__bases__ = tuple(bases) - - ns0.VmfsDatastoreSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreBaseOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreBaseOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreBaseOption_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmfsDatastoreBaseOption_Def.__bases__: - bases = list(ns0.VmfsDatastoreBaseOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmfsDatastoreBaseOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreSingleExtentOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreSingleExtentOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreSingleExtentOption_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"vmfsExtent"), aname="_vmfsExtent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsDatastoreBaseOption_Def not in ns0.VmfsDatastoreSingleExtentOption_Def.__bases__: - bases = list(ns0.VmfsDatastoreSingleExtentOption_Def.__bases__) - bases.insert(0, ns0.VmfsDatastoreBaseOption_Def) - ns0.VmfsDatastoreSingleExtentOption_Def.__bases__ = tuple(bases) - - ns0.VmfsDatastoreBaseOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreAllExtentOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreAllExtentOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreAllExtentOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsDatastoreSingleExtentOption_Def not in ns0.VmfsDatastoreAllExtentOption_Def.__bases__: - bases = list(ns0.VmfsDatastoreAllExtentOption_Def.__bases__) - bases.insert(0, ns0.VmfsDatastoreSingleExtentOption_Def) - ns0.VmfsDatastoreAllExtentOption_Def.__bases__ = tuple(bases) - - ns0.VmfsDatastoreSingleExtentOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreMultipleExtentOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreMultipleExtentOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreMultipleExtentOption_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"vmfsExtent"), aname="_vmfsExtent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmfsDatastoreBaseOption_Def not in ns0.VmfsDatastoreMultipleExtentOption_Def.__bases__: - bases = list(ns0.VmfsDatastoreMultipleExtentOption_Def.__bases__) - bases.insert(0, ns0.VmfsDatastoreBaseOption_Def) - ns0.VmfsDatastoreMultipleExtentOption_Def.__bases__ = tuple(bases) - - ns0.VmfsDatastoreBaseOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmfsDatastoreOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmfsDatastoreOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmfsDatastoreOption_Def.schema - TClist = [GTD("urn:vim25","VmfsDatastoreBaseOption",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmfsDatastoreSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmfsDatastoreOption_Def.__bases__: - bases = list(ns0.VmfsDatastoreOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmfsDatastoreOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVmfsDatastoreOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVmfsDatastoreOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVmfsDatastoreOption_Def.schema - TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"VmfsDatastoreOption"), aname="_VmfsDatastoreOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VmfsDatastoreOption = [] - return - Holder.__name__ = "ArrayOfVmfsDatastoreOption_Holder" - self.pyclass = Holder - - class HostDateTimeConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDateTimeConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDateTimeConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNtpConfig",lazy=True)(pname=(ns,"ntpConfig"), aname="_ntpConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDateTimeConfig_Def.__bases__: - bases = list(ns0.HostDateTimeConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDateTimeConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDateTimeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDateTimeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDateTimeInfo_Def.schema - TClist = [GTD("urn:vim25","HostDateTimeSystemTimeZone",lazy=True)(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNtpConfig",lazy=True)(pname=(ns,"ntpConfig"), aname="_ntpConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDateTimeInfo_Def.__bases__: - bases = list(ns0.HostDateTimeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDateTimeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDateTimeSystemTimeZone_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDateTimeSystemTimeZone") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDateTimeSystemTimeZone_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"gmtOffset"), aname="_gmtOffset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDateTimeSystemTimeZone_Def.__bases__: - bases = list(ns0.HostDateTimeSystemTimeZone_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDateTimeSystemTimeZone_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDateTimeSystemTimeZone_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDateTimeSystemTimeZone") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDateTimeSystemTimeZone_Def.schema - TClist = [GTD("urn:vim25","HostDateTimeSystemTimeZone",lazy=True)(pname=(ns,"HostDateTimeSystemTimeZone"), aname="_HostDateTimeSystemTimeZone", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDateTimeSystemTimeZone = [] - return - Holder.__name__ = "ArrayOfHostDateTimeSystemTimeZone_Holder" - self.pyclass = Holder - - class UpdateDateTimeConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateDateTimeConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateDateTimeConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDateTimeConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - return - Holder.__name__ = "UpdateDateTimeConfigRequestType_Holder" - self.pyclass = Holder - - class QueryAvailableTimeZonesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryAvailableTimeZonesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryAvailableTimeZonesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryAvailableTimeZonesRequestType_Holder" - self.pyclass = Holder - - class QueryDateTimeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryDateTimeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryDateTimeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryDateTimeRequestType_Holder" - self.pyclass = Holder - - class UpdateDateTimeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateDateTimeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateDateTimeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"dateTime"), aname="_dateTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._dateTime = None - return - Holder.__name__ = "UpdateDateTimeRequestType_Holder" - self.pyclass = Holder - - class RefreshDateTimeSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshDateTimeSystemRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshDateTimeSystemRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshDateTimeSystemRequestType_Holder" - self.pyclass = Holder - - class HostDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDevice_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceType"), aname="_deviceType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDevice_Def.__bases__: - bases = list(ns0.HostDevice_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDevice_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDhcpServiceSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDhcpServiceSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDhcpServiceSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"virtualSwitch"), aname="_virtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultLeaseDuration"), aname="_defaultLeaseDuration", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"leaseBeginIp"), aname="_leaseBeginIp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"leaseEndIp"), aname="_leaseEndIp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxLeaseDuration"), aname="_maxLeaseDuration", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"unlimitedLease"), aname="_unlimitedLease", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipSubnetAddr"), aname="_ipSubnetAddr", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipSubnetMask"), aname="_ipSubnetMask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDhcpServiceSpec_Def.__bases__: - bases = list(ns0.HostDhcpServiceSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDhcpServiceSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDhcpServiceConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDhcpServiceConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDhcpServiceConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDhcpServiceConfig_Def.__bases__: - bases = list(ns0.HostDhcpServiceConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDhcpServiceConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDhcpServiceConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDhcpServiceConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDhcpServiceConfig_Def.schema - TClist = [GTD("urn:vim25","HostDhcpServiceConfig",lazy=True)(pname=(ns,"HostDhcpServiceConfig"), aname="_HostDhcpServiceConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDhcpServiceConfig = [] - return - Holder.__name__ = "ArrayOfHostDhcpServiceConfig_Holder" - self.pyclass = Holder - - class HostDhcpService_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDhcpService") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDhcpService_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDhcpService_Def.__bases__: - bases = list(ns0.HostDhcpService_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDhcpService_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDhcpService_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDhcpService") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDhcpService_Def.schema - TClist = [GTD("urn:vim25","HostDhcpService",lazy=True)(pname=(ns,"HostDhcpService"), aname="_HostDhcpService", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDhcpService = [] - return - Holder.__name__ = "ArrayOfHostDhcpService_Holder" - self.pyclass = Holder - - class QueryAvailablePartitionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryAvailablePartitionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryAvailablePartitionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryAvailablePartitionRequestType_Holder" - self.pyclass = Holder - - class SelectActivePartitionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SelectActivePartitionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SelectActivePartitionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._partition = None - return - Holder.__name__ = "SelectActivePartitionRequestType_Holder" - self.pyclass = Holder - - class QueryPartitionCreateOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPartitionCreateOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPartitionCreateOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._storageType = None - self._diagnosticType = None - return - Holder.__name__ = "QueryPartitionCreateOptionsRequestType_Holder" - self.pyclass = Holder - - class QueryPartitionCreateDescRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPartitionCreateDescRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPartitionCreateDescRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskUuid"), aname="_diskUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._diskUuid = None - self._diagnosticType = None - return - Holder.__name__ = "QueryPartitionCreateDescRequestType_Holder" - self.pyclass = Holder - - class CreateDiagnosticPartitionRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateDiagnosticPartitionRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateDiagnosticPartitionRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiagnosticPartitionCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "CreateDiagnosticPartitionRequestType_Holder" - self.pyclass = Holder - - class DiagnosticPartitionStorageType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DiagnosticPartitionStorageType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class DiagnosticPartitionType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DiagnosticPartitionType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostDiagnosticPartitionCreateOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiagnosticPartitionCreateOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiagnosticPartitionCreateOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiagnosticPartitionCreateOption_Def.__bases__: - bases = list(ns0.HostDiagnosticPartitionCreateOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiagnosticPartitionCreateOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDiagnosticPartitionCreateOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDiagnosticPartitionCreateOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDiagnosticPartitionCreateOption_Def.schema - TClist = [GTD("urn:vim25","HostDiagnosticPartitionCreateOption",lazy=True)(pname=(ns,"HostDiagnosticPartitionCreateOption"), aname="_HostDiagnosticPartitionCreateOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDiagnosticPartitionCreateOption = [] - return - Holder.__name__ = "ArrayOfHostDiagnosticPartitionCreateOption_Holder" - self.pyclass = Holder - - class HostDiagnosticPartitionCreateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiagnosticPartitionCreateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiagnosticPartitionCreateSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"active"), aname="_active", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiagnosticPartitionCreateSpec_Def.__bases__: - bases = list(ns0.HostDiagnosticPartitionCreateSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiagnosticPartitionCreateSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiagnosticPartitionCreateDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiagnosticPartitionCreateDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiagnosticPartitionCreateDescription_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskUuid"), aname="_diskUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiagnosticPartitionCreateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiagnosticPartitionCreateDescription_Def.__bases__: - bases = list(ns0.HostDiagnosticPartitionCreateDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiagnosticPartitionCreateDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiagnosticPartition_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiagnosticPartition") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiagnosticPartition_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"storageType"), aname="_storageType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diagnosticType"), aname="_diagnosticType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"slots"), aname="_slots", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiagnosticPartition_Def.__bases__: - bases = list(ns0.HostDiagnosticPartition_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiagnosticPartition_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDiagnosticPartition_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDiagnosticPartition") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDiagnosticPartition_Def.schema - TClist = [GTD("urn:vim25","HostDiagnosticPartition",lazy=True)(pname=(ns,"HostDiagnosticPartition"), aname="_HostDiagnosticPartition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDiagnosticPartition = [] - return - Holder.__name__ = "ArrayOfHostDiagnosticPartition_Holder" - self.pyclass = Holder - - class HostDiskDimensionsChs_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskDimensionsChs") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskDimensionsChs_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"cylinder"), aname="_cylinder", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"head"), aname="_head", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"sector"), aname="_sector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskDimensionsChs_Def.__bases__: - bases = list(ns0.HostDiskDimensionsChs_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskDimensionsChs_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiskDimensionsLba_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskDimensionsLba") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskDimensionsLba_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"blockSize"), aname="_blockSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"block"), aname="_block", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskDimensionsLba_Def.__bases__: - bases = list(ns0.HostDiskDimensionsLba_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskDimensionsLba_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiskDimensions_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskDimensions") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskDimensions_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskDimensions_Def.__bases__: - bases = list(ns0.HostDiskDimensions_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskDimensions_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiskPartitionInfoType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostDiskPartitionInfoType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostDiskPartitionAttributes_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskPartitionAttributes") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskPartitionAttributes_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"startSector"), aname="_startSector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"endSector"), aname="_endSector", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"logical"), aname="_logical", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"attributes"), aname="_attributes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskPartitionAttributes_Def.__bases__: - bases = list(ns0.HostDiskPartitionAttributes_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskPartitionAttributes_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDiskPartitionAttributes_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDiskPartitionAttributes") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDiskPartitionAttributes_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionAttributes",lazy=True)(pname=(ns,"HostDiskPartitionAttributes"), aname="_HostDiskPartitionAttributes", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDiskPartitionAttributes = [] - return - Holder.__name__ = "ArrayOfHostDiskPartitionAttributes_Holder" - self.pyclass = Holder - - class HostDiskPartitionBlockRange_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskPartitionBlockRange") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskPartitionBlockRange_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"start"), aname="_start", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"end"), aname="_end", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskPartitionBlockRange_Def.__bases__: - bases = list(ns0.HostDiskPartitionBlockRange_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskPartitionBlockRange_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDiskPartitionBlockRange_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDiskPartitionBlockRange") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDiskPartitionBlockRange_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"HostDiskPartitionBlockRange"), aname="_HostDiskPartitionBlockRange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDiskPartitionBlockRange = [] - return - Holder.__name__ = "ArrayOfHostDiskPartitionBlockRange_Holder" - self.pyclass = Holder - - class HostDiskPartitionSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskPartitionSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskPartitionSpec_Def.schema - TClist = [GTD("urn:vim25","HostDiskDimensionsChs",lazy=True)(pname=(ns,"chs"), aname="_chs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"totalSectors"), aname="_totalSectors", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionAttributes",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskPartitionSpec_Def.__bases__: - bases = list(ns0.HostDiskPartitionSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskPartitionSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiskPartitionLayout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskPartitionLayout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskPartitionLayout_Def.schema - TClist = [GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"total"), aname="_total", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskPartitionLayout_Def.__bases__: - bases = list(ns0.HostDiskPartitionLayout_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskPartitionLayout_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiskPartitionInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskPartitionInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskPartitionInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskPartitionInfo_Def.__bases__: - bases = list(ns0.HostDiskPartitionInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskPartitionInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDiskPartitionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDiskPartitionInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDiskPartitionInfo_Def.schema - TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"HostDiskPartitionInfo"), aname="_HostDiskPartitionInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDiskPartitionInfo = [] - return - Holder.__name__ = "ArrayOfHostDiskPartitionInfo_Holder" - self.pyclass = Holder - - class HostDnsConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDnsConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDnsConfig_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"virtualNicDevice"), aname="_virtualNicDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domainName"), aname="_domainName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"searchDomain"), aname="_searchDomain", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDnsConfig_Def.__bases__: - bases = list(ns0.HostDnsConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDnsConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDnsConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDnsConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDnsConfigSpec_Def.schema - TClist = [GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"virtualNicConnection"), aname="_virtualNicConnection", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDnsConfig_Def not in ns0.HostDnsConfigSpec_Def.__bases__: - bases = list(ns0.HostDnsConfigSpec_Def.__bases__) - bases.insert(0, ns0.HostDnsConfig_Def) - ns0.HostDnsConfigSpec_Def.__bases__ = tuple(bases) - - ns0.HostDnsConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ModeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ModeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ModeInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"browse"), aname="_browse", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"read"), aname="_read", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"modify"), aname="_modify", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"use"), aname="_use", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"admin"), aname="_admin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"full"), aname="_full", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ModeInfo_Def.__bases__: - bases = list(ns0.ModeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ModeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFileAccess_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFileAccess") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFileAccess_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"who"), aname="_who", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"what"), aname="_what", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFileAccess_Def.__bases__: - bases = list(ns0.HostFileAccess_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFileAccess_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFileSystemVolumeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFileSystemVolumeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFileSystemVolumeInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"volumeTypeList"), aname="_volumeTypeList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFileSystemMountInfo",lazy=True)(pname=(ns,"mountInfo"), aname="_mountInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFileSystemVolumeInfo_Def.__bases__: - bases = list(ns0.HostFileSystemVolumeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFileSystemVolumeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFileSystemMountInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFileSystemMountInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFileSystemMountInfo_Def.schema - TClist = [GTD("urn:vim25","HostMountInfo",lazy=True)(pname=(ns,"mountInfo"), aname="_mountInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFileSystemVolume",lazy=True)(pname=(ns,"volume"), aname="_volume", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFileSystemMountInfo_Def.__bases__: - bases = list(ns0.HostFileSystemMountInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFileSystemMountInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostFileSystemMountInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostFileSystemMountInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostFileSystemMountInfo_Def.schema - TClist = [GTD("urn:vim25","HostFileSystemMountInfo",lazy=True)(pname=(ns,"HostFileSystemMountInfo"), aname="_HostFileSystemMountInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostFileSystemMountInfo = [] - return - Holder.__name__ = "ArrayOfHostFileSystemMountInfo_Holder" - self.pyclass = Holder - - class HostFileSystemVolume_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFileSystemVolume") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFileSystemVolume_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFileSystemVolume_Def.__bases__: - bases = list(ns0.HostFileSystemVolume_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFileSystemVolume_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNasVolumeSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNasVolumeSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNasVolumeSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localPath"), aname="_localPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"accessMode"), aname="_accessMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNasVolumeSpec_Def.__bases__: - bases = list(ns0.HostNasVolumeSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNasVolumeSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNasVolumeConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNasVolumeConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNasVolumeConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNasVolumeSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNasVolumeConfig_Def.__bases__: - bases = list(ns0.HostNasVolumeConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNasVolumeConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostNasVolumeConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostNasVolumeConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostNasVolumeConfig_Def.schema - TClist = [GTD("urn:vim25","HostNasVolumeConfig",lazy=True)(pname=(ns,"HostNasVolumeConfig"), aname="_HostNasVolumeConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostNasVolumeConfig = [] - return - Holder.__name__ = "ArrayOfHostNasVolumeConfig_Holder" - self.pyclass = Holder - - class HostNasVolume_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNasVolume") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNasVolume_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"remoteHost"), aname="_remoteHost", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"remotePath"), aname="_remotePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostFileSystemVolume_Def not in ns0.HostNasVolume_Def.__bases__: - bases = list(ns0.HostNasVolume_Def.__bases__) - bases.insert(0, ns0.HostFileSystemVolume_Def) - ns0.HostNasVolume_Def.__bases__ = tuple(bases) - - ns0.HostFileSystemVolume_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostLocalFileSystemVolumeSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostLocalFileSystemVolumeSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostLocalFileSystemVolumeSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"localPath"), aname="_localPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostLocalFileSystemVolumeSpec_Def.__bases__: - bases = list(ns0.HostLocalFileSystemVolumeSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostLocalFileSystemVolumeSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostLocalFileSystemVolume_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostLocalFileSystemVolume") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostLocalFileSystemVolume_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostFileSystemVolume_Def not in ns0.HostLocalFileSystemVolume_Def.__bases__: - bases = list(ns0.HostLocalFileSystemVolume_Def.__bases__) - bases.insert(0, ns0.HostFileSystemVolume_Def) - ns0.HostLocalFileSystemVolume_Def.__bases__ = tuple(bases) - - ns0.HostFileSystemVolume_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFirewallConfigRuleSetConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFirewallConfigRuleSetConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFirewallConfigRuleSetConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"rulesetId"), aname="_rulesetId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFirewallConfigRuleSetConfig_Def.__bases__: - bases = list(ns0.HostFirewallConfigRuleSetConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFirewallConfigRuleSetConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostFirewallConfigRuleSetConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostFirewallConfigRuleSetConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostFirewallConfigRuleSetConfig_Def.schema - TClist = [GTD("urn:vim25","HostFirewallConfigRuleSetConfig",lazy=True)(pname=(ns,"HostFirewallConfigRuleSetConfig"), aname="_HostFirewallConfigRuleSetConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostFirewallConfigRuleSetConfig = [] - return - Holder.__name__ = "ArrayOfHostFirewallConfigRuleSetConfig_Holder" - self.pyclass = Holder - - class HostFirewallConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFirewallConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFirewallConfig_Def.schema - TClist = [GTD("urn:vim25","HostFirewallConfigRuleSetConfig",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallDefaultPolicy",lazy=True)(pname=(ns,"defaultBlockingPolicy"), aname="_defaultBlockingPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFirewallConfig_Def.__bases__: - bases = list(ns0.HostFirewallConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFirewallConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFirewallDefaultPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFirewallDefaultPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFirewallDefaultPolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"incomingBlocked"), aname="_incomingBlocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"outgoingBlocked"), aname="_outgoingBlocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFirewallDefaultPolicy_Def.__bases__: - bases = list(ns0.HostFirewallDefaultPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFirewallDefaultPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFirewallInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFirewallInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFirewallInfo_Def.schema - TClist = [GTD("urn:vim25","HostFirewallDefaultPolicy",lazy=True)(pname=(ns,"defaultPolicy"), aname="_defaultPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallRuleset",lazy=True)(pname=(ns,"ruleset"), aname="_ruleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFirewallInfo_Def.__bases__: - bases = list(ns0.HostFirewallInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFirewallInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateDefaultPolicyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateDefaultPolicyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateDefaultPolicyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallDefaultPolicy",lazy=True)(pname=(ns,"defaultPolicy"), aname="_defaultPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._defaultPolicy = None - return - Holder.__name__ = "UpdateDefaultPolicyRequestType_Holder" - self.pyclass = Holder - - class EnableRulesetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EnableRulesetRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.EnableRulesetRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._id = None - return - Holder.__name__ = "EnableRulesetRequestType_Holder" - self.pyclass = Holder - - class DisableRulesetRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DisableRulesetRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DisableRulesetRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._id = None - return - Holder.__name__ = "DisableRulesetRequestType_Holder" - self.pyclass = Holder - - class RefreshFirewallRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshFirewallRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshFirewallRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshFirewallRequestType_Holder" - self.pyclass = Holder - - class ResetFirmwareToFactoryDefaultsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetFirmwareToFactoryDefaultsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetFirmwareToFactoryDefaultsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ResetFirmwareToFactoryDefaultsRequestType_Holder" - self.pyclass = Holder - - class BackupFirmwareConfigurationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "BackupFirmwareConfigurationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.BackupFirmwareConfigurationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "BackupFirmwareConfigurationRequestType_Holder" - self.pyclass = Holder - - class QueryFirmwareConfigUploadURLRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryFirmwareConfigUploadURLRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryFirmwareConfigUploadURLRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryFirmwareConfigUploadURLRequestType_Holder" - self.pyclass = Holder - - class RestoreFirmwareConfigurationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RestoreFirmwareConfigurationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RestoreFirmwareConfigurationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._force = None - return - Holder.__name__ = "RestoreFirmwareConfigurationRequestType_Holder" - self.pyclass = Holder - - class HostFlagInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFlagInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFlagInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"backgroundSnapshotsEnabled"), aname="_backgroundSnapshotsEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFlagInfo_Def.__bases__: - bases = list(ns0.HostFlagInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFlagInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostForceMountedInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostForceMountedInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostForceMountedInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"persist"), aname="_persist", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mounted"), aname="_mounted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostForceMountedInfo_Def.__bases__: - bases = list(ns0.HostForceMountedInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostForceMountedInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostHardwareInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostHardwareInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostHardwareInfo_Def.schema - TClist = [GTD("urn:vim25","HostSystemInfo",lazy=True)(pname=(ns,"systemInfo"), aname="_systemInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuPowerManagementInfo",lazy=True)(pname=(ns,"cpuPowerManagementInfo"), aname="_cpuPowerManagementInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuInfo",lazy=True)(pname=(ns,"cpuInfo"), aname="_cpuInfo", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuPackage",lazy=True)(pname=(ns,"cpuPkg"), aname="_cpuPkg", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memorySize"), aname="_memorySize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNumaInfo",lazy=True)(pname=(ns,"numaInfo"), aname="_numaInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPciDevice",lazy=True)(pname=(ns,"pciDevice"), aname="_pciDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeature"), aname="_cpuFeature", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostBIOSInfo",lazy=True)(pname=(ns,"biosInfo"), aname="_biosInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostHardwareInfo_Def.__bases__: - bases = list(ns0.HostHardwareInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostHardwareInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostSystemInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSystemInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSystemInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemIdentificationInfo",lazy=True)(pname=(ns,"otherIdentifyingInfo"), aname="_otherIdentifyingInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSystemInfo_Def.__bases__: - bases = list(ns0.HostSystemInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSystemInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCpuPowerManagementInfoPolicyType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostCpuPowerManagementInfoPolicyType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostCpuPowerManagementInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCpuPowerManagementInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCpuPowerManagementInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"currentPolicy"), aname="_currentPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hardwareSupport"), aname="_hardwareSupport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostCpuPowerManagementInfo_Def.__bases__: - bases = list(ns0.HostCpuPowerManagementInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostCpuPowerManagementInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCpuInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCpuInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCpuInfo_Def.schema - TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"numCpuPackages"), aname="_numCpuPackages", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuThreads"), aname="_numCpuThreads", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hz"), aname="_hz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostCpuInfo_Def.__bases__: - bases = list(ns0.HostCpuInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostCpuInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostCpuPackageVendor_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostCpuPackageVendor") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostCpuPackage_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostCpuPackage") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostCpuPackage_Def.schema - TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"index"), aname="_index", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hz"), aname="_hz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"busHz"), aname="_busHz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"threadId"), aname="_threadId", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeature"), aname="_cpuFeature", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostCpuPackage_Def.__bases__: - bases = list(ns0.HostCpuPackage_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostCpuPackage_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostCpuPackage_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostCpuPackage") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostCpuPackage_Def.schema - TClist = [GTD("urn:vim25","HostCpuPackage",lazy=True)(pname=(ns,"HostCpuPackage"), aname="_HostCpuPackage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostCpuPackage = [] - return - Holder.__name__ = "ArrayOfHostCpuPackage_Holder" - self.pyclass = Holder - - class HostNumaInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNumaInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNumaInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNodes"), aname="_numNodes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNumaNode",lazy=True)(pname=(ns,"numaNode"), aname="_numaNode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNumaInfo_Def.__bases__: - bases = list(ns0.HostNumaInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNumaInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNumaNode_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNumaNode") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNumaNode_Def.schema - TClist = [ZSI.TCnumbers.Ibyte(pname=(ns,"typeId"), aname="_typeId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"cpuID"), aname="_cpuID", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryRangeBegin"), aname="_memoryRangeBegin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryRangeLength"), aname="_memoryRangeLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNumaNode_Def.__bases__: - bases = list(ns0.HostNumaNode_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNumaNode_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostNumaNode_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostNumaNode") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostNumaNode_Def.schema - TClist = [GTD("urn:vim25","HostNumaNode",lazy=True)(pname=(ns,"HostNumaNode"), aname="_HostNumaNode", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostNumaNode = [] - return - Holder.__name__ = "ArrayOfHostNumaNode_Holder" - self.pyclass = Holder - - class HostBIOSInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostBIOSInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostBIOSInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"biosVersion"), aname="_biosVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"releaseDate"), aname="_releaseDate", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostBIOSInfo_Def.__bases__: - bases = list(ns0.HostBIOSInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostBIOSInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostHardwareElementStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostHardwareElementStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostHardwareElementInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostHardwareElementInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostHardwareElementInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostHardwareElementInfo_Def.__bases__: - bases = list(ns0.HostHardwareElementInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostHardwareElementInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostHardwareElementInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostHardwareElementInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostHardwareElementInfo_Def.schema - TClist = [GTD("urn:vim25","HostHardwareElementInfo",lazy=True)(pname=(ns,"HostHardwareElementInfo"), aname="_HostHardwareElementInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostHardwareElementInfo = [] - return - Holder.__name__ = "ArrayOfHostHardwareElementInfo_Holder" - self.pyclass = Holder - - class HostStorageOperationalInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostStorageOperationalInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostStorageOperationalInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"property"), aname="_property", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostStorageOperationalInfo_Def.__bases__: - bases = list(ns0.HostStorageOperationalInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostStorageOperationalInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostStorageOperationalInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostStorageOperationalInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostStorageOperationalInfo_Def.schema - TClist = [GTD("urn:vim25","HostStorageOperationalInfo",lazy=True)(pname=(ns,"HostStorageOperationalInfo"), aname="_HostStorageOperationalInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostStorageOperationalInfo = [] - return - Holder.__name__ = "ArrayOfHostStorageOperationalInfo_Holder" - self.pyclass = Holder - - class HostStorageElementInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostStorageElementInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostStorageElementInfo_Def.schema - TClist = [GTD("urn:vim25","HostStorageOperationalInfo",lazy=True)(pname=(ns,"operationalInfo"), aname="_operationalInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostHardwareElementInfo_Def not in ns0.HostStorageElementInfo_Def.__bases__: - bases = list(ns0.HostStorageElementInfo_Def.__bases__) - bases.insert(0, ns0.HostHardwareElementInfo_Def) - ns0.HostStorageElementInfo_Def.__bases__ = tuple(bases) - - ns0.HostHardwareElementInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostStorageElementInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostStorageElementInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostStorageElementInfo_Def.schema - TClist = [GTD("urn:vim25","HostStorageElementInfo",lazy=True)(pname=(ns,"HostStorageElementInfo"), aname="_HostStorageElementInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostStorageElementInfo = [] - return - Holder.__name__ = "ArrayOfHostStorageElementInfo_Holder" - self.pyclass = Holder - - class HostHardwareStatusInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostHardwareStatusInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostHardwareStatusInfo_Def.schema - TClist = [GTD("urn:vim25","HostHardwareElementInfo",lazy=True)(pname=(ns,"memoryStatusInfo"), aname="_memoryStatusInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHardwareElementInfo",lazy=True)(pname=(ns,"cpuStatusInfo"), aname="_cpuStatusInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostStorageElementInfo",lazy=True)(pname=(ns,"storageStatusInfo"), aname="_storageStatusInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostHardwareStatusInfo_Def.__bases__: - bases = list(ns0.HostHardwareStatusInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostHardwareStatusInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HealthSystemRuntime_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HealthSystemRuntime") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HealthSystemRuntime_Def.schema - TClist = [GTD("urn:vim25","HostSystemHealthInfo",lazy=True)(pname=(ns,"systemHealthInfo"), aname="_systemHealthInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHardwareStatusInfo",lazy=True)(pname=(ns,"hardwareStatusInfo"), aname="_hardwareStatusInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HealthSystemRuntime_Def.__bases__: - bases = list(ns0.HealthSystemRuntime_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HealthSystemRuntime_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RefreshHealthStatusSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshHealthStatusSystemRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshHealthStatusSystemRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshHealthStatusSystemRequestType_Holder" - self.pyclass = Holder - - class ResetSystemHealthInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetSystemHealthInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetSystemHealthInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ResetSystemHealthInfoRequestType_Holder" - self.pyclass = Holder - - class HostHostBusAdapter_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostHostBusAdapter") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostHostBusAdapter_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"bus"), aname="_bus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"driver"), aname="_driver", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pci"), aname="_pci", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostHostBusAdapter_Def.__bases__: - bases = list(ns0.HostHostBusAdapter_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostHostBusAdapter_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostHostBusAdapter_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostHostBusAdapter") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostHostBusAdapter_Def.schema - TClist = [GTD("urn:vim25","HostHostBusAdapter",lazy=True)(pname=(ns,"HostHostBusAdapter"), aname="_HostHostBusAdapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostHostBusAdapter = [] - return - Holder.__name__ = "ArrayOfHostHostBusAdapter_Holder" - self.pyclass = Holder - - class HostParallelScsiHba_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostParallelScsiHba") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostParallelScsiHba_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostHostBusAdapter_Def not in ns0.HostParallelScsiHba_Def.__bases__: - bases = list(ns0.HostParallelScsiHba_Def.__bases__) - bases.insert(0, ns0.HostHostBusAdapter_Def) - ns0.HostParallelScsiHba_Def.__bases__ = tuple(bases) - - ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostBlockHba_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostBlockHba") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostBlockHba_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostHostBusAdapter_Def not in ns0.HostBlockHba_Def.__bases__: - bases = list(ns0.HostBlockHba_Def.__bases__) - bases.insert(0, ns0.HostHostBusAdapter_Def) - ns0.HostBlockHba_Def.__bases__ = tuple(bases) - - ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FibreChannelPortType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FibreChannelPortType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostFibreChannelHba_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFibreChannelHba") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFibreChannelHba_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"portWorldWideName"), aname="_portWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"nodeWorldWideName"), aname="_nodeWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FibreChannelPortType",lazy=True)(pname=(ns,"portType"), aname="_portType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"speed"), aname="_speed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostHostBusAdapter_Def not in ns0.HostFibreChannelHba_Def.__bases__: - bases = list(ns0.HostFibreChannelHba_Def.__bases__) - bases.insert(0, ns0.HostHostBusAdapter_Def) - ns0.HostFibreChannelHba_Def.__bases__ = tuple(bases) - - ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaParamValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaParamValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaParamValue_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"isInherited"), aname="_isInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OptionValue_Def not in ns0.HostInternetScsiHbaParamValue_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaParamValue_Def.__bases__) - bases.insert(0, ns0.OptionValue_Def) - ns0.HostInternetScsiHbaParamValue_Def.__bases__ = tuple(bases) - - ns0.OptionValue_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostInternetScsiHbaParamValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostInternetScsiHbaParamValue") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostInternetScsiHbaParamValue_Def.schema - TClist = [GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"HostInternetScsiHbaParamValue"), aname="_HostInternetScsiHbaParamValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostInternetScsiHbaParamValue = [] - return - Holder.__name__ = "ArrayOfHostInternetScsiHbaParamValue_Holder" - self.pyclass = Holder - - class HostInternetScsiHbaDiscoveryCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaDiscoveryCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"iSnsDiscoverySettable"), aname="_iSnsDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"slpDiscoverySettable"), aname="_slpDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"staticTargetDiscoverySettable"), aname="_staticTargetDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sendTargetsDiscoverySettable"), aname="_sendTargetsDiscoverySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaDiscoveryCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class InternetScsiSnsDiscoveryMethod_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "InternetScsiSnsDiscoveryMethod") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class SlpDiscoveryMethod_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SlpDiscoveryMethod") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostInternetScsiHbaDiscoveryProperties_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaDiscoveryProperties") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaDiscoveryProperties_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"iSnsDiscoveryEnabled"), aname="_iSnsDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iSnsDiscoveryMethod"), aname="_iSnsDiscoveryMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iSnsHost"), aname="_iSnsHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"slpDiscoveryEnabled"), aname="_slpDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"slpDiscoveryMethod"), aname="_slpDiscoveryMethod", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"slpHost"), aname="_slpHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"staticTargetDiscoveryEnabled"), aname="_staticTargetDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sendTargetsDiscoveryEnabled"), aname="_sendTargetsDiscoveryEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDiscoveryProperties_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaDiscoveryProperties_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaDiscoveryProperties_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaChapAuthenticationType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaChapAuthenticationType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostInternetScsiHbaAuthenticationCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaAuthenticationCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"chapAuthSettable"), aname="_chapAuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"krb5AuthSettable"), aname="_krb5AuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"srpAuthSettable"), aname="_srpAuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"spkmAuthSettable"), aname="_spkmAuthSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mutualChapSettable"), aname="_mutualChapSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetChapSettable"), aname="_targetChapSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetMutualChapSettable"), aname="_targetMutualChapSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaAuthenticationCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaAuthenticationProperties_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaAuthenticationProperties") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaAuthenticationProperties_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"chapAuthEnabled"), aname="_chapAuthEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"chapName"), aname="_chapName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"chapSecret"), aname="_chapSecret", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"chapAuthenticationType"), aname="_chapAuthenticationType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"chapInherited"), aname="_chapInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mutualChapName"), aname="_mutualChapName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mutualChapSecret"), aname="_mutualChapSecret", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mutualChapAuthenticationType"), aname="_mutualChapAuthenticationType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mutualChapInherited"), aname="_mutualChapInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaAuthenticationProperties_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaAuthenticationProperties_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaAuthenticationProperties_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaDigestType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaDigestType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostInternetScsiHbaDigestCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaDigestCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaDigestCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"headerDigestSettable"), aname="_headerDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dataDigestSettable"), aname="_dataDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetHeaderDigestSettable"), aname="_targetHeaderDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"targetDataDigestSettable"), aname="_targetDataDigestSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDigestCapabilities_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaDigestCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaDigestCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaDigestProperties_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaDigestProperties") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaDigestProperties_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"headerDigestType"), aname="_headerDigestType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"headerDigestInherited"), aname="_headerDigestInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dataDigestType"), aname="_dataDigestType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dataDigestInherited"), aname="_dataDigestInherited", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaDigestProperties_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaDigestProperties_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaDigestProperties_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaIPCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaIPCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaIPCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"addressSettable"), aname="_addressSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipConfigurationMethodSettable"), aname="_ipConfigurationMethodSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"subnetMaskSettable"), aname="_subnetMaskSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"defaultGatewaySettable"), aname="_defaultGatewaySettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"primaryDnsServerAddressSettable"), aname="_primaryDnsServerAddressSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"alternateDnsServerAddressSettable"), aname="_alternateDnsServerAddressSettable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipv6Supported"), aname="_ipv6Supported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"arpRedirectSettable"), aname="_arpRedirectSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"mtuSettable"), aname="_mtuSettable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hostNameAsTargetAddress"), aname="_hostNameAsTargetAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaIPCapabilities_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaIPCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaIPCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaIPProperties_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaIPProperties") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaIPProperties_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpConfigurationEnabled"), aname="_dhcpConfigurationEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultGateway"), aname="_defaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"primaryDnsServerAddress"), aname="_primaryDnsServerAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"alternateDnsServerAddress"), aname="_alternateDnsServerAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipv6Address"), aname="_ipv6Address", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipv6SubnetMask"), aname="_ipv6SubnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipv6DefaultGateway"), aname="_ipv6DefaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"arpRedirectEnabled"), aname="_arpRedirectEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"jumboFramesEnabled"), aname="_jumboFramesEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaIPProperties_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaIPProperties_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaIPProperties_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHbaSendTarget_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaSendTarget") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaSendTarget_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"supportedAdvancedOptions"), aname="_supportedAdvancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"advancedOptions"), aname="_advancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaSendTarget_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaSendTarget_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaSendTarget_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostInternetScsiHbaSendTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostInternetScsiHbaSendTarget") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostInternetScsiHbaSendTarget_Def.schema - TClist = [GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"HostInternetScsiHbaSendTarget"), aname="_HostInternetScsiHbaSendTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostInternetScsiHbaSendTarget = [] - return - Holder.__name__ = "ArrayOfHostInternetScsiHbaSendTarget_Holder" - self.pyclass = Holder - - class HostInternetScsiHbaStaticTarget_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaStaticTarget") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaStaticTarget_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"supportedAdvancedOptions"), aname="_supportedAdvancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"advancedOptions"), aname="_advancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaStaticTarget_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaStaticTarget_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaStaticTarget_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostInternetScsiHbaStaticTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostInternetScsiHbaStaticTarget") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostInternetScsiHbaStaticTarget_Def.schema - TClist = [GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"HostInternetScsiHbaStaticTarget"), aname="_HostInternetScsiHbaStaticTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostInternetScsiHbaStaticTarget = [] - return - Holder.__name__ = "ArrayOfHostInternetScsiHbaStaticTarget_Holder" - self.pyclass = Holder - - class HostInternetScsiHbaTargetSet_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHbaTargetSet") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHbaTargetSet_Def.schema - TClist = [GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"staticTargets"), aname="_staticTargets", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"sendTargets"), aname="_sendTargets", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostInternetScsiHbaTargetSet_Def.__bases__: - bases = list(ns0.HostInternetScsiHbaTargetSet_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostInternetScsiHbaTargetSet_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiHba_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiHba") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiHba_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"isSoftwareBased"), aname="_isSoftwareBased", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDiscoveryCapabilities",lazy=True)(pname=(ns,"discoveryCapabilities"), aname="_discoveryCapabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDiscoveryProperties",lazy=True)(pname=(ns,"discoveryProperties"), aname="_discoveryProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationCapabilities",lazy=True)(pname=(ns,"authenticationCapabilities"), aname="_authenticationCapabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestCapabilities",lazy=True)(pname=(ns,"digestCapabilities"), aname="_digestCapabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaIPCapabilities",lazy=True)(pname=(ns,"ipCapabilities"), aname="_ipCapabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaIPProperties",lazy=True)(pname=(ns,"ipProperties"), aname="_ipProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"supportedAdvancedOptions"), aname="_supportedAdvancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"advancedOptions"), aname="_advancedOptions", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiAlias"), aname="_iScsiAlias", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"configuredSendTarget"), aname="_configuredSendTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"configuredStaticTarget"), aname="_configuredStaticTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxSpeedMb"), aname="_maxSpeedMb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"currentSpeedMb"), aname="_currentSpeedMb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostHostBusAdapter_Def not in ns0.HostInternetScsiHba_Def.__bases__: - bases = list(ns0.HostInternetScsiHba_Def.__bases__) - bases.insert(0, ns0.HostHostBusAdapter_Def) - ns0.HostInternetScsiHba_Def.__bases__ = tuple(bases) - - ns0.HostHostBusAdapter_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProxySwitchSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProxySwitchSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProxySwitchSpec_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostMemberBacking",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostProxySwitchSpec_Def.__bases__: - bases = list(ns0.HostProxySwitchSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostProxySwitchSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProxySwitchConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProxySwitchConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProxySwitchConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostProxySwitchConfig_Def.__bases__: - bases = list(ns0.HostProxySwitchConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostProxySwitchConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostProxySwitchConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostProxySwitchConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostProxySwitchConfig_Def.schema - TClist = [GTD("urn:vim25","HostProxySwitchConfig",lazy=True)(pname=(ns,"HostProxySwitchConfig"), aname="_HostProxySwitchConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostProxySwitchConfig = [] - return - Holder.__name__ = "ArrayOfHostProxySwitchConfig_Holder" - self.pyclass = Holder - - class HostProxySwitch_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProxySwitch") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProxySwitch_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"dvsUuid"), aname="_dvsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dvsName"), aname="_dvsName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPortsAvailable"), aname="_numPortsAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"uplinkPort"), aname="_uplinkPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostProxySwitch_Def.__bases__: - bases = list(ns0.HostProxySwitch_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostProxySwitch_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostProxySwitch_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostProxySwitch") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostProxySwitch_Def.schema - TClist = [GTD("urn:vim25","HostProxySwitch",lazy=True)(pname=(ns,"HostProxySwitch"), aname="_HostProxySwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostProxySwitch = [] - return - Holder.__name__ = "ArrayOfHostProxySwitch_Holder" - self.pyclass = Holder - - class HostIpConfigIpV6AddressConfigType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostIpConfigIpV6AddressConfigType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostIpConfigIpV6AddressStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostIpConfigIpV6AddressStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostIpConfigIpV6Address_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpConfigIpV6Address") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpConfigIpV6Address_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"prefixLength"), aname="_prefixLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"origin"), aname="_origin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dadState"), aname="_dadState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lifetime"), aname="_lifetime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpConfigIpV6Address_Def.__bases__: - bases = list(ns0.HostIpConfigIpV6Address_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpConfigIpV6Address_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostIpConfigIpV6Address_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostIpConfigIpV6Address") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostIpConfigIpV6Address_Def.schema - TClist = [GTD("urn:vim25","HostIpConfigIpV6Address",lazy=True)(pname=(ns,"HostIpConfigIpV6Address"), aname="_HostIpConfigIpV6Address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostIpConfigIpV6Address = [] - return - Holder.__name__ = "ArrayOfHostIpConfigIpV6Address_Holder" - self.pyclass = Holder - - class HostIpConfigIpV6AddressConfiguration_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpConfigIpV6AddressConfiguration") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpConfigIpV6AddressConfiguration_Def.schema - TClist = [GTD("urn:vim25","HostIpConfigIpV6Address",lazy=True)(pname=(ns,"ipV6Address"), aname="_ipV6Address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoConfigurationEnabled"), aname="_autoConfigurationEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpV6Enabled"), aname="_dhcpV6Enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpConfigIpV6AddressConfiguration_Def.__bases__: - bases = list(ns0.HostIpConfigIpV6AddressConfiguration_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpConfigIpV6AddressConfiguration_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpConfig_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpConfigIpV6AddressConfiguration",lazy=True)(pname=(ns,"ipV6Config"), aname="_ipV6Config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpConfig_Def.__bases__: - bases = list(ns0.HostIpConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpRouteConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpRouteConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpRouteConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"defaultGateway"), aname="_defaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gatewayDevice"), aname="_gatewayDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipV6DefaultGateway"), aname="_ipV6DefaultGateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipV6GatewayDevice"), aname="_ipV6GatewayDevice", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpRouteConfig_Def.__bases__: - bases = list(ns0.HostIpRouteConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpRouteConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpRouteConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpRouteConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpRouteConfigSpec_Def.schema - TClist = [GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"gatewayDeviceConnection"), aname="_gatewayDeviceConnection", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"ipV6GatewayDeviceConnection"), aname="_ipV6GatewayDeviceConnection", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostIpRouteConfig_Def not in ns0.HostIpRouteConfigSpec_Def.__bases__: - bases = list(ns0.HostIpRouteConfigSpec_Def.__bases__) - bases.insert(0, ns0.HostIpRouteConfig_Def) - ns0.HostIpRouteConfigSpec_Def.__bases__ = tuple(bases) - - ns0.HostIpRouteConfig_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpRouteEntry_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpRouteEntry") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpRouteEntry_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"prefixLength"), aname="_prefixLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpRouteEntry_Def.__bases__: - bases = list(ns0.HostIpRouteEntry_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpRouteEntry_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostIpRouteEntry_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostIpRouteEntry") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostIpRouteEntry_Def.schema - TClist = [GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"HostIpRouteEntry"), aname="_HostIpRouteEntry", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostIpRouteEntry = [] - return - Holder.__name__ = "ArrayOfHostIpRouteEntry_Holder" - self.pyclass = Holder - - class HostIpRouteOp_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpRouteOp") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpRouteOp_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"route"), aname="_route", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpRouteOp_Def.__bases__: - bases = list(ns0.HostIpRouteOp_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpRouteOp_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostIpRouteOp_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostIpRouteOp") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostIpRouteOp_Def.schema - TClist = [GTD("urn:vim25","HostIpRouteOp",lazy=True)(pname=(ns,"HostIpRouteOp"), aname="_HostIpRouteOp", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostIpRouteOp = [] - return - Holder.__name__ = "ArrayOfHostIpRouteOp_Holder" - self.pyclass = Holder - - class HostIpRouteTableConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpRouteTableConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpRouteTableConfig_Def.schema - TClist = [GTD("urn:vim25","HostIpRouteOp",lazy=True)(pname=(ns,"ipRoute"), aname="_ipRoute", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteOp",lazy=True)(pname=(ns,"ipv6Route"), aname="_ipv6Route", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpRouteTableConfig_Def.__bases__: - bases = list(ns0.HostIpRouteTableConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpRouteTableConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpRouteTableInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpRouteTableInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpRouteTableInfo_Def.schema - TClist = [GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"ipRoute"), aname="_ipRoute", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteEntry",lazy=True)(pname=(ns,"ipv6Route"), aname="_ipv6Route", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpRouteTableInfo_Def.__bases__: - bases = list(ns0.HostIpRouteTableInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpRouteTableInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostIpmiInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostIpmiInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostIpmiInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"bmcIpAddress"), aname="_bmcIpAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bmcMacAddress"), aname="_bmcMacAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"login"), aname="_login", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostIpmiInfo_Def.__bases__: - bases = list(ns0.HostIpmiInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostIpmiInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class KernelModuleSectionInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "KernelModuleSectionInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.KernelModuleSectionInfo_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"address"), aname="_address", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"length"), aname="_length", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.KernelModuleSectionInfo_Def.__bases__: - bases = list(ns0.KernelModuleSectionInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.KernelModuleSectionInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class KernelModuleInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "KernelModuleInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.KernelModuleInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"filename"), aname="_filename", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"optionString"), aname="_optionString", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"loaded"), aname="_loaded", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"useCount"), aname="_useCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"readOnlySection"), aname="_readOnlySection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"writableSection"), aname="_writableSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"textSection"), aname="_textSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"dataSection"), aname="_dataSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KernelModuleSectionInfo",lazy=True)(pname=(ns,"bssSection"), aname="_bssSection", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.KernelModuleInfo_Def.__bases__: - bases = list(ns0.KernelModuleInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.KernelModuleInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfKernelModuleInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfKernelModuleInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfKernelModuleInfo_Def.schema - TClist = [GTD("urn:vim25","KernelModuleInfo",lazy=True)(pname=(ns,"KernelModuleInfo"), aname="_KernelModuleInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._KernelModuleInfo = [] - return - Holder.__name__ = "ArrayOfKernelModuleInfo_Holder" - self.pyclass = Holder - - class QueryModulesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryModulesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryModulesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryModulesRequestType_Holder" - self.pyclass = Holder - - class UpdateModuleOptionStringRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateModuleOptionStringRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateModuleOptionStringRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"options"), aname="_options", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._options = None - return - Holder.__name__ = "UpdateModuleOptionStringRequestType_Holder" - self.pyclass = Holder - - class QueryConfiguredModuleOptionStringRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryConfiguredModuleOptionStringRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryConfiguredModuleOptionStringRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - return - Holder.__name__ = "QueryConfiguredModuleOptionStringRequestType_Holder" - self.pyclass = Holder - - class HostLicenseSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostLicenseSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostLicenseSpec_Def.schema - TClist = [GTD("urn:vim25","LicenseSource",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"editionKey"), aname="_editionKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"disabledFeatureKey"), aname="_disabledFeatureKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"enabledFeatureKey"), aname="_enabledFeatureKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostLicenseSpec_Def.__bases__: - bases = list(ns0.HostLicenseSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostLicenseSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LinkDiscoveryProtocolConfigProtocolType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LinkDiscoveryProtocolConfigProtocolType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LinkDiscoveryProtocolConfigOperationType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "LinkDiscoveryProtocolConfigOperationType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class LinkDiscoveryProtocolConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LinkDiscoveryProtocolConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LinkDiscoveryProtocolConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"protocol"), aname="_protocol", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.LinkDiscoveryProtocolConfig_Def.__bases__: - bases = list(ns0.LinkDiscoveryProtocolConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.LinkDiscoveryProtocolConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostAccountSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostAccountSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostAccountSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostAccountSpec_Def.__bases__: - bases = list(ns0.HostAccountSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostAccountSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostAccountSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostAccountSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostAccountSpec_Def.schema - TClist = [GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"HostAccountSpec"), aname="_HostAccountSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostAccountSpec = [] - return - Holder.__name__ = "ArrayOfHostAccountSpec_Holder" - self.pyclass = Holder - - class HostPosixAccountSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPosixAccountSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPosixAccountSpec_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"posixId"), aname="_posixId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"shellAccess"), aname="_shellAccess", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostAccountSpec_Def not in ns0.HostPosixAccountSpec_Def.__bases__: - bases = list(ns0.HostPosixAccountSpec_Def.__bases__) - bases.insert(0, ns0.HostAccountSpec_Def) - ns0.HostPosixAccountSpec_Def.__bases__ = tuple(bases) - - ns0.HostAccountSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CreateUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateUserRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateUserRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._user = None - return - Holder.__name__ = "CreateUserRequestType_Holder" - self.pyclass = Holder - - class UpdateUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateUserRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateUserRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._user = None - return - Holder.__name__ = "UpdateUserRequestType_Holder" - self.pyclass = Holder - - class CreateGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateGroupRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateGroupRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostAccountSpec",lazy=True)(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._group = None - return - Holder.__name__ = "CreateGroupRequestType_Holder" - self.pyclass = Holder - - class RemoveUserRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveUserRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveUserRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._userName = None - return - Holder.__name__ = "RemoveUserRequestType_Holder" - self.pyclass = Holder - - class RemoveGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveGroupRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveGroupRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"groupName"), aname="_groupName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._groupName = None - return - Holder.__name__ = "RemoveGroupRequestType_Holder" - self.pyclass = Holder - - class AssignUserToGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AssignUserToGroupRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AssignUserToGroupRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._user = None - self._group = None - return - Holder.__name__ = "AssignUserToGroupRequestType_Holder" - self.pyclass = Holder - - class UnassignUserFromGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UnassignUserFromGroupRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UnassignUserFromGroupRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"user"), aname="_user", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"group"), aname="_group", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._user = None - self._group = None - return - Holder.__name__ = "UnassignUserFromGroupRequestType_Holder" - self.pyclass = Holder - - class HostLowLevelProvisioningManagerReloadTarget_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostLowLevelProvisioningManagerReloadTarget") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ServiceConsoleReservationInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ServiceConsoleReservationInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ServiceConsoleReservationInfo_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"serviceConsoleReservedCfg"), aname="_serviceConsoleReservedCfg", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"serviceConsoleReserved"), aname="_serviceConsoleReserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unreserved"), aname="_unreserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ServiceConsoleReservationInfo_Def.__bases__: - bases = list(ns0.ServiceConsoleReservationInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ServiceConsoleReservationInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineMemoryAllocationPolicy_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineMemoryAllocationPolicy") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineMemoryReservationInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineMemoryReservationInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineMemoryReservationInfo_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineMin"), aname="_virtualMachineMin", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineMax"), aname="_virtualMachineMax", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineReserved"), aname="_virtualMachineReserved", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"allocationPolicy"), aname="_allocationPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineMemoryReservationInfo_Def.__bases__: - bases = list(ns0.VirtualMachineMemoryReservationInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineMemoryReservationInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineMemoryReservationSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineMemoryReservationSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineMemoryReservationSpec_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"virtualMachineReserved"), aname="_virtualMachineReserved", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"allocationPolicy"), aname="_allocationPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineMemoryReservationSpec_Def.__bases__: - bases = list(ns0.VirtualMachineMemoryReservationSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineMemoryReservationSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReconfigureServiceConsoleReservationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureServiceConsoleReservationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureServiceConsoleReservationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"cfgBytes"), aname="_cfgBytes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._cfgBytes = None - return - Holder.__name__ = "ReconfigureServiceConsoleReservationRequestType_Holder" - self.pyclass = Holder - - class ReconfigureVirtualMachineReservationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureVirtualMachineReservationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureVirtualMachineReservationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMemoryReservationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "ReconfigureVirtualMachineReservationRequestType_Holder" - self.pyclass = Holder - - class HostMemorySpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMemorySpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMemorySpec_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"serviceConsoleReservation"), aname="_serviceConsoleReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMemorySpec_Def.__bases__: - bases = list(ns0.HostMemorySpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMemorySpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostMountMode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostMountMode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostMountInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMountInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMountInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"accessMode"), aname="_accessMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"accessible"), aname="_accessible", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMountInfo_Def.__bases__: - bases = list(ns0.HostMountInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMountInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MultipathState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "MultipathState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostMultipathInfoLogicalUnitPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathInfoLogicalUnitPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathInfoLogicalUnitPolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMultipathInfoLogicalUnitPolicy_Def.__bases__: - bases = list(ns0.HostMultipathInfoLogicalUnitPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMultipathInfoLogicalUnitPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathInfoLogicalUnitStorageArrayTypePolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.__bases__: - bases = list(ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMultipathInfoLogicalUnitStorageArrayTypePolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostMultipathInfoFixedLogicalUnitPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathInfoFixedLogicalUnitPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"prefer"), aname="_prefer", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostMultipathInfoLogicalUnitPolicy_Def not in ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.__bases__: - bases = list(ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.__bases__) - bases.insert(0, ns0.HostMultipathInfoLogicalUnitPolicy_Def) - ns0.HostMultipathInfoFixedLogicalUnitPolicy_Def.__bases__ = tuple(bases) - - ns0.HostMultipathInfoLogicalUnitPolicy_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostMultipathInfoLogicalUnit_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathInfoLogicalUnit") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathInfoLogicalUnit_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoLogicalUnitPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoLogicalUnitStorageArrayTypePolicy",lazy=True)(pname=(ns,"storageArrayTypePolicy"), aname="_storageArrayTypePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMultipathInfoLogicalUnit_Def.__bases__: - bases = list(ns0.HostMultipathInfoLogicalUnit_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMultipathInfoLogicalUnit_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostMultipathInfoLogicalUnit_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostMultipathInfoLogicalUnit") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostMultipathInfoLogicalUnit_Def.schema - TClist = [GTD("urn:vim25","HostMultipathInfoLogicalUnit",lazy=True)(pname=(ns,"HostMultipathInfoLogicalUnit"), aname="_HostMultipathInfoLogicalUnit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostMultipathInfoLogicalUnit = [] - return - Holder.__name__ = "ArrayOfHostMultipathInfoLogicalUnit_Holder" - self.pyclass = Holder - - class HostMultipathInfoPath_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathInfoPath") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathInfoPath_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathState"), aname="_pathState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"isWorkingPath"), aname="_isWorkingPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTargetTransport",lazy=True)(pname=(ns,"transport"), aname="_transport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMultipathInfoPath_Def.__bases__: - bases = list(ns0.HostMultipathInfoPath_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMultipathInfoPath_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostMultipathInfoPath_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostMultipathInfoPath") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostMultipathInfoPath_Def.schema - TClist = [GTD("urn:vim25","HostMultipathInfoPath",lazy=True)(pname=(ns,"HostMultipathInfoPath"), aname="_HostMultipathInfoPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostMultipathInfoPath = [] - return - Holder.__name__ = "ArrayOfHostMultipathInfoPath_Holder" - self.pyclass = Holder - - class HostMultipathInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathInfo_Def.schema - TClist = [GTD("urn:vim25","HostMultipathInfoLogicalUnit",lazy=True)(pname=(ns,"lun"), aname="_lun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMultipathInfo_Def.__bases__: - bases = list(ns0.HostMultipathInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMultipathInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostMultipathStateInfoPath_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathStateInfoPath") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathStateInfoPath_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathState"), aname="_pathState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMultipathStateInfoPath_Def.__bases__: - bases = list(ns0.HostMultipathStateInfoPath_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMultipathStateInfoPath_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostMultipathStateInfoPath_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostMultipathStateInfoPath") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostMultipathStateInfoPath_Def.schema - TClist = [GTD("urn:vim25","HostMultipathStateInfoPath",lazy=True)(pname=(ns,"HostMultipathStateInfoPath"), aname="_HostMultipathStateInfoPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostMultipathStateInfoPath = [] - return - Holder.__name__ = "ArrayOfHostMultipathStateInfoPath_Holder" - self.pyclass = Holder - - class HostMultipathStateInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMultipathStateInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMultipathStateInfo_Def.schema - TClist = [GTD("urn:vim25","HostMultipathStateInfoPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostMultipathStateInfo_Def.__bases__: - bases = list(ns0.HostMultipathStateInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostMultipathStateInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNatServicePortForwardSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNatServicePortForwardSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNatServicePortForwardSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostPort"), aname="_hostPort", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"guestPort"), aname="_guestPort", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestIpAddress"), aname="_guestIpAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNatServicePortForwardSpec_Def.__bases__: - bases = list(ns0.HostNatServicePortForwardSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNatServicePortForwardSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostNatServicePortForwardSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostNatServicePortForwardSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostNatServicePortForwardSpec_Def.schema - TClist = [GTD("urn:vim25","HostNatServicePortForwardSpec",lazy=True)(pname=(ns,"HostNatServicePortForwardSpec"), aname="_HostNatServicePortForwardSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostNatServicePortForwardSpec = [] - return - Holder.__name__ = "ArrayOfHostNatServicePortForwardSpec_Holder" - self.pyclass = Holder - - class HostNatServiceNameServiceSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNatServiceNameServiceSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNatServiceNameServiceSpec_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"dnsAutoDetect"), aname="_dnsAutoDetect", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsPolicy"), aname="_dnsPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dnsRetries"), aname="_dnsRetries", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dnsTimeout"), aname="_dnsTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsNameServer"), aname="_dnsNameServer", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"nbdsTimeout"), aname="_nbdsTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"nbnsRetries"), aname="_nbnsRetries", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"nbnsTimeout"), aname="_nbnsTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNatServiceNameServiceSpec_Def.__bases__: - bases = list(ns0.HostNatServiceNameServiceSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNatServiceNameServiceSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNatServiceSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNatServiceSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNatServiceSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"virtualSwitch"), aname="_virtualSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"activeFtp"), aname="_activeFtp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"allowAnyOui"), aname="_allowAnyOui", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"configPort"), aname="_configPort", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipGatewayAddress"), aname="_ipGatewayAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"udpTimeout"), aname="_udpTimeout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServicePortForwardSpec",lazy=True)(pname=(ns,"portForward"), aname="_portForward", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceNameServiceSpec",lazy=True)(pname=(ns,"nameService"), aname="_nameService", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNatServiceSpec_Def.__bases__: - bases = list(ns0.HostNatServiceSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNatServiceSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNatServiceConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNatServiceConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNatServiceConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNatServiceConfig_Def.__bases__: - bases = list(ns0.HostNatServiceConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNatServiceConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostNatServiceConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostNatServiceConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostNatServiceConfig_Def.schema - TClist = [GTD("urn:vim25","HostNatServiceConfig",lazy=True)(pname=(ns,"HostNatServiceConfig"), aname="_HostNatServiceConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostNatServiceConfig = [] - return - Holder.__name__ = "ArrayOfHostNatServiceConfig_Holder" - self.pyclass = Holder - - class HostNatService_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNatService") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNatService_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNatService_Def.__bases__: - bases = list(ns0.HostNatService_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNatService_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostNatService_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostNatService") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostNatService_Def.schema - TClist = [GTD("urn:vim25","HostNatService",lazy=True)(pname=(ns,"HostNatService"), aname="_HostNatService", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostNatService = [] - return - Holder.__name__ = "ArrayOfHostNatService_Holder" - self.pyclass = Holder - - class HostNetCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"canSetPhysicalNicLinkSpeed"), aname="_canSetPhysicalNicLinkSpeed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsNicTeaming"), aname="_supportsNicTeaming", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicTeamingPolicy"), aname="_nicTeamingPolicy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsVlan"), aname="_supportsVlan", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"usesServiceConsoleNic"), aname="_usesServiceConsoleNic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsNetworkHints"), aname="_supportsNetworkHints", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxPortGroupsPerVswitch"), aname="_maxPortGroupsPerVswitch", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vswitchConfigSupported"), aname="_vswitchConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vnicConfigSupported"), aname="_vnicConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipRouteConfigSupported"), aname="_ipRouteConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dnsConfigSupported"), aname="_dnsConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpOnVnicSupported"), aname="_dhcpOnVnicSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipV6Supported"), aname="_ipV6Supported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetCapabilities_Def.__bases__: - bases = list(ns0.HostNetCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNetOffloadCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetOffloadCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetOffloadCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"csumOffload"), aname="_csumOffload", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tcpSegmentation"), aname="_tcpSegmentation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"zeroCopyXmit"), aname="_zeroCopyXmit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetOffloadCapabilities_Def.__bases__: - bases = list(ns0.HostNetOffloadCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetOffloadCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNetworkConfigResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetworkConfigResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetworkConfigResult_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vnicDevice"), aname="_vnicDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"consoleVnicDevice"), aname="_consoleVnicDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetworkConfigResult_Def.__bases__: - bases = list(ns0.HostNetworkConfigResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetworkConfigResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNetworkConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetworkConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetworkConfig_Def.schema - TClist = [GTD("urn:vim25","HostVirtualSwitchConfig",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitchConfig",lazy=True)(pname=(ns,"proxySwitch"), aname="_proxySwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupConfig",lazy=True)(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicConfig",lazy=True)(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicConfig",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicConfig",lazy=True)(pname=(ns,"consoleVnic"), aname="_consoleVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDnsConfig",lazy=True)(pname=(ns,"dnsConfig"), aname="_dnsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"ipRouteConfig"), aname="_ipRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"consoleIpRouteConfig"), aname="_consoleIpRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteTableConfig",lazy=True)(pname=(ns,"routeTableConfig"), aname="_routeTableConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpServiceConfig",lazy=True)(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatServiceConfig",lazy=True)(pname=(ns,"nat"), aname="_nat", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipV6Enabled"), aname="_ipV6Enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetworkConfig_Def.__bases__: - bases = list(ns0.HostNetworkConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetworkConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNetworkInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetworkInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetworkInfo_Def.schema - TClist = [GTD("urn:vim25","HostVirtualSwitch",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProxySwitch",lazy=True)(pname=(ns,"proxySwitch"), aname="_proxySwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroup",lazy=True)(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNic",lazy=True)(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"consoleVnic"), aname="_consoleVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDnsConfig",lazy=True)(pname=(ns,"dnsConfig"), aname="_dnsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"ipRouteConfig"), aname="_ipRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"consoleIpRouteConfig"), aname="_consoleIpRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteTableInfo",lazy=True)(pname=(ns,"routeTableInfo"), aname="_routeTableInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDhcpService",lazy=True)(pname=(ns,"dhcp"), aname="_dhcp", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNatService",lazy=True)(pname=(ns,"nat"), aname="_nat", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipV6Enabled"), aname="_ipV6Enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetworkInfo_Def.__bases__: - bases = list(ns0.HostNetworkInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetworkInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNetworkSecurityPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetworkSecurityPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetworkSecurityPolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"allowPromiscuous"), aname="_allowPromiscuous", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"macChanges"), aname="_macChanges", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"forgedTransmits"), aname="_forgedTransmits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetworkSecurityPolicy_Def.__bases__: - bases = list(ns0.HostNetworkSecurityPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetworkSecurityPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNetworkTrafficShapingPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetworkTrafficShapingPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetworkTrafficShapingPolicy_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"averageBandwidth"), aname="_averageBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"peakBandwidth"), aname="_peakBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"burstSize"), aname="_burstSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetworkTrafficShapingPolicy_Def.__bases__: - bases = list(ns0.HostNetworkTrafficShapingPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetworkTrafficShapingPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNicFailureCriteria_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNicFailureCriteria") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNicFailureCriteria_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"checkSpeed"), aname="_checkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"speed"), aname="_speed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"checkDuplex"), aname="_checkDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fullDuplex"), aname="_fullDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"checkErrorPercent"), aname="_checkErrorPercent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"percentage"), aname="_percentage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"checkBeacon"), aname="_checkBeacon", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNicFailureCriteria_Def.__bases__: - bases = list(ns0.HostNicFailureCriteria_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNicFailureCriteria_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNicOrderPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNicOrderPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNicOrderPolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"activeNic"), aname="_activeNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"standbyNic"), aname="_standbyNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNicOrderPolicy_Def.__bases__: - bases = list(ns0.HostNicOrderPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNicOrderPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNicTeamingPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNicTeamingPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNicTeamingPolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"reversePolicy"), aname="_reversePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"notifySwitches"), aname="_notifySwitches", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rollingOrder"), aname="_rollingOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNicFailureCriteria",lazy=True)(pname=(ns,"failureCriteria"), aname="_failureCriteria", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNicOrderPolicy",lazy=True)(pname=(ns,"nicOrder"), aname="_nicOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNicTeamingPolicy_Def.__bases__: - bases = list(ns0.HostNicTeamingPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNicTeamingPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNetworkPolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNetworkPolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNetworkPolicy_Def.schema - TClist = [GTD("urn:vim25","HostNetworkSecurityPolicy",lazy=True)(pname=(ns,"security"), aname="_security", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNicTeamingPolicy",lazy=True)(pname=(ns,"nicTeaming"), aname="_nicTeaming", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetOffloadCapabilities",lazy=True)(pname=(ns,"offloadPolicy"), aname="_offloadPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkTrafficShapingPolicy",lazy=True)(pname=(ns,"shapingPolicy"), aname="_shapingPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNetworkPolicy_Def.__bases__: - bases = list(ns0.HostNetworkPolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNetworkPolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateNetworkConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateNetworkConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateNetworkConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeMode"), aname="_changeMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - self._changeMode = None - return - Holder.__name__ = "UpdateNetworkConfigRequestType_Holder" - self.pyclass = Holder - - class UpdateDnsConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateDnsConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateDnsConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDnsConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - return - Holder.__name__ = "UpdateDnsConfigRequestType_Holder" - self.pyclass = Holder - - class UpdateIpRouteConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateIpRouteConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateIpRouteConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - return - Holder.__name__ = "UpdateIpRouteConfigRequestType_Holder" - self.pyclass = Holder - - class UpdateConsoleIpRouteConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateConsoleIpRouteConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateConsoleIpRouteConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - return - Holder.__name__ = "UpdateConsoleIpRouteConfigRequestType_Holder" - self.pyclass = Holder - - class UpdateIpRouteTableConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateIpRouteTableConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateIpRouteTableConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpRouteTableConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - return - Holder.__name__ = "UpdateIpRouteTableConfigRequestType_Holder" - self.pyclass = Holder - - class AddVirtualSwitchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddVirtualSwitchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddVirtualSwitchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vswitchName = None - self._spec = None - return - Holder.__name__ = "AddVirtualSwitchRequestType_Holder" - self.pyclass = Holder - - class RemoveVirtualSwitchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveVirtualSwitchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveVirtualSwitchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vswitchName = None - return - Holder.__name__ = "RemoveVirtualSwitchRequestType_Holder" - self.pyclass = Holder - - class UpdateVirtualSwitchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateVirtualSwitchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateVirtualSwitchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vswitchName = None - self._spec = None - return - Holder.__name__ = "UpdateVirtualSwitchRequestType_Holder" - self.pyclass = Holder - - class AddPortGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddPortGroupRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddPortGroupRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"portgrp"), aname="_portgrp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._portgrp = None - return - Holder.__name__ = "AddPortGroupRequestType_Holder" - self.pyclass = Holder - - class RemovePortGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemovePortGroupRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemovePortGroupRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pgName"), aname="_pgName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._pgName = None - return - Holder.__name__ = "RemovePortGroupRequestType_Holder" - self.pyclass = Holder - - class UpdatePortGroupRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdatePortGroupRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdatePortGroupRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pgName"), aname="_pgName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"portgrp"), aname="_portgrp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._pgName = None - self._portgrp = None - return - Holder.__name__ = "UpdatePortGroupRequestType_Holder" - self.pyclass = Holder - - class UpdatePhysicalNicLinkSpeedRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdatePhysicalNicLinkSpeedRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdatePhysicalNicLinkSpeedRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"linkSpeed"), aname="_linkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = None - self._linkSpeed = None - return - Holder.__name__ = "UpdatePhysicalNicLinkSpeedRequestType_Holder" - self.pyclass = Holder - - class QueryNetworkHintRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryNetworkHintRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryNetworkHintRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = [] - return - Holder.__name__ = "QueryNetworkHintRequestType_Holder" - self.pyclass = Holder - - class AddVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddVirtualNicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddVirtualNicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._portgroup = None - self._nic = None - return - Holder.__name__ = "AddVirtualNicRequestType_Holder" - self.pyclass = Holder - - class RemoveVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveVirtualNicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveVirtualNicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = None - return - Holder.__name__ = "RemoveVirtualNicRequestType_Holder" - self.pyclass = Holder - - class UpdateVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateVirtualNicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateVirtualNicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = None - self._nic = None - return - Holder.__name__ = "UpdateVirtualNicRequestType_Holder" - self.pyclass = Holder - - class AddServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddServiceConsoleVirtualNicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddServiceConsoleVirtualNicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._portgroup = None - self._nic = None - return - Holder.__name__ = "AddServiceConsoleVirtualNicRequestType_Holder" - self.pyclass = Holder - - class RemoveServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveServiceConsoleVirtualNicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveServiceConsoleVirtualNicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = None - return - Holder.__name__ = "RemoveServiceConsoleVirtualNicRequestType_Holder" - self.pyclass = Holder - - class UpdateServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateServiceConsoleVirtualNicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateServiceConsoleVirtualNicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"nic"), aname="_nic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = None - self._nic = None - return - Holder.__name__ = "UpdateServiceConsoleVirtualNicRequestType_Holder" - self.pyclass = Holder - - class RestartServiceConsoleVirtualNicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RestartServiceConsoleVirtualNicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RestartServiceConsoleVirtualNicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = None - return - Holder.__name__ = "RestartServiceConsoleVirtualNicRequestType_Holder" - self.pyclass = Holder - - class RefreshNetworkSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshNetworkSystemRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshNetworkSystemRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshNetworkSystemRequestType_Holder" - self.pyclass = Holder - - class HostNtpConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNtpConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNtpConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"server"), aname="_server", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNtpConfig_Def.__bases__: - bases = list(ns0.HostNtpConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNtpConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostNumericSensorHealthState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostNumericSensorHealthState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostNumericSensorType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostNumericSensorType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostNumericSensorInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostNumericSensorInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostNumericSensorInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"healthState"), aname="_healthState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"currentReading"), aname="_currentReading", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"unitModifier"), aname="_unitModifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"baseUnits"), aname="_baseUnits", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rateUnits"), aname="_rateUnits", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sensorType"), aname="_sensorType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostNumericSensorInfo_Def.__bases__: - bases = list(ns0.HostNumericSensorInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostNumericSensorInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostNumericSensorInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostNumericSensorInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostNumericSensorInfo_Def.schema - TClist = [GTD("urn:vim25","HostNumericSensorInfo",lazy=True)(pname=(ns,"HostNumericSensorInfo"), aname="_HostNumericSensorInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostNumericSensorInfo = [] - return - Holder.__name__ = "ArrayOfHostNumericSensorInfo_Holder" - self.pyclass = Holder - - class HostPatchManagerResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPatchManagerResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPatchManagerResult_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerStatus",lazy=True)(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"xmlResult"), aname="_xmlResult", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPatchManagerResult_Def.__bases__: - bases = list(ns0.HostPatchManagerResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPatchManagerResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostPatchManagerReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostPatchManagerReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostPatchManagerIntegrityStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostPatchManagerIntegrityStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostPatchManagerInstallState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostPatchManagerInstallState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostPatchManagerStatusPrerequisitePatch_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPatchManagerStatusPrerequisitePatch") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPatchManagerStatusPrerequisitePatch_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installState"), aname="_installState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPatchManagerStatusPrerequisitePatch_Def.__bases__: - bases = list(ns0.HostPatchManagerStatusPrerequisitePatch_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPatchManagerStatusPrerequisitePatch_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPatchManagerStatusPrerequisitePatch_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPatchManagerStatusPrerequisitePatch") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPatchManagerStatusPrerequisitePatch_Def.schema - TClist = [GTD("urn:vim25","HostPatchManagerStatusPrerequisitePatch",lazy=True)(pname=(ns,"HostPatchManagerStatusPrerequisitePatch"), aname="_HostPatchManagerStatusPrerequisitePatch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPatchManagerStatusPrerequisitePatch = [] - return - Holder.__name__ = "ArrayOfHostPatchManagerStatusPrerequisitePatch_Holder" - self.pyclass = Holder - - class HostPatchManagerStatus_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPatchManagerStatus") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPatchManagerStatus_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"applicable"), aname="_applicable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"integrity"), aname="_integrity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installed"), aname="_installed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"installState"), aname="_installState", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerStatusPrerequisitePatch",lazy=True)(pname=(ns,"prerequisitePatch"), aname="_prerequisitePatch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"restartRequired"), aname="_restartRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"reconnectRequired"), aname="_reconnectRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmOffRequired"), aname="_vmOffRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supersededPatchIds"), aname="_supersededPatchIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPatchManagerStatus_Def.__bases__: - bases = list(ns0.HostPatchManagerStatus_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPatchManagerStatus_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPatchManagerStatus_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPatchManagerStatus") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPatchManagerStatus_Def.schema - TClist = [GTD("urn:vim25","HostPatchManagerStatus",lazy=True)(pname=(ns,"HostPatchManagerStatus"), aname="_HostPatchManagerStatus", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPatchManagerStatus = [] - return - Holder.__name__ = "ArrayOfHostPatchManagerStatus_Holder" - self.pyclass = Holder - - class HostPatchManagerLocator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPatchManagerLocator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPatchManagerLocator_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"proxy"), aname="_proxy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPatchManagerLocator_Def.__bases__: - bases = list(ns0.HostPatchManagerLocator_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPatchManagerLocator_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostPatchManagerPatchManagerOperationSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPatchManagerPatchManagerOperationSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPatchManagerPatchManagerOperationSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"proxy"), aname="_proxy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"userName"), aname="_userName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cmdOption"), aname="_cmdOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPatchManagerPatchManagerOperationSpec_Def.__bases__: - bases = list(ns0.HostPatchManagerPatchManagerOperationSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPatchManagerPatchManagerOperationSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CheckHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckHostPatchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckHostPatchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._metaUrls = [] - self._bundleUrls = [] - self._spec = None - return - Holder.__name__ = "CheckHostPatchRequestType_Holder" - self.pyclass = Holder - - class ScanHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ScanHostPatchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ScanHostPatchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerLocator",lazy=True)(pname=(ns,"repository"), aname="_repository", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"updateID"), aname="_updateID", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._repository = None - self._updateID = [] - return - Holder.__name__ = "ScanHostPatchRequestType_Holder" - self.pyclass = Holder - - class ScanHostPatchV2RequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ScanHostPatchV2RequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ScanHostPatchV2RequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._metaUrls = [] - self._bundleUrls = [] - self._spec = None - return - Holder.__name__ = "ScanHostPatchV2RequestType_Holder" - self.pyclass = Holder - - class StageHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StageHostPatchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StageHostPatchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vibUrls"), aname="_vibUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._metaUrls = [] - self._bundleUrls = [] - self._vibUrls = [] - self._spec = None - return - Holder.__name__ = "StageHostPatchRequestType_Holder" - self.pyclass = Holder - - class InstallHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "InstallHostPatchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.InstallHostPatchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerLocator",lazy=True)(pname=(ns,"repository"), aname="_repository", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"updateID"), aname="_updateID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"force"), aname="_force", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._repository = None - self._updateID = None - self._force = None - return - Holder.__name__ = "InstallHostPatchRequestType_Holder" - self.pyclass = Holder - - class InstallHostPatchV2RequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "InstallHostPatchV2RequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.InstallHostPatchV2RequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"metaUrls"), aname="_metaUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bundleUrls"), aname="_bundleUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vibUrls"), aname="_vibUrls", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._metaUrls = [] - self._bundleUrls = [] - self._vibUrls = [] - self._spec = None - return - Holder.__name__ = "InstallHostPatchV2RequestType_Holder" - self.pyclass = Holder - - class UninstallHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UninstallHostPatchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UninstallHostPatchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"bulletinIds"), aname="_bulletinIds", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._bulletinIds = [] - self._spec = None - return - Holder.__name__ = "UninstallHostPatchRequestType_Holder" - self.pyclass = Holder - - class QueryHostPatchRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryHostPatchRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryHostPatchRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPatchManagerPatchManagerOperationSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "QueryHostPatchRequestType_Holder" - self.pyclass = Holder - - class HostPathSelectionPolicyOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPathSelectionPolicyOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPathSelectionPolicyOption_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPathSelectionPolicyOption_Def.__bases__: - bases = list(ns0.HostPathSelectionPolicyOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPathSelectionPolicyOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPathSelectionPolicyOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPathSelectionPolicyOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPathSelectionPolicyOption_Def.schema - TClist = [GTD("urn:vim25","HostPathSelectionPolicyOption",lazy=True)(pname=(ns,"HostPathSelectionPolicyOption"), aname="_HostPathSelectionPolicyOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPathSelectionPolicyOption = [] - return - Holder.__name__ = "ArrayOfHostPathSelectionPolicyOption_Holder" - self.pyclass = Holder - - class HostPciDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPciDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPciDevice_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"classId"), aname="_classId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"bus"), aname="_bus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"slot"), aname="_slot", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"function"), aname="_function", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"vendorId"), aname="_vendorId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"subVendorId"), aname="_subVendorId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendorName"), aname="_vendorName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"subDeviceId"), aname="_subDeviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"parentBridge"), aname="_parentBridge", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPciDevice_Def.__bases__: - bases = list(ns0.HostPciDevice_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPciDevice_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPciDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPciDevice") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPciDevice_Def.schema - TClist = [GTD("urn:vim25","HostPciDevice",lazy=True)(pname=(ns,"HostPciDevice"), aname="_HostPciDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPciDevice = [] - return - Holder.__name__ = "ArrayOfHostPciDevice_Holder" - self.pyclass = Holder - - class HostPciPassthruConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPciPassthruConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPciPassthruConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruEnabled"), aname="_passthruEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPciPassthruConfig_Def.__bases__: - bases = list(ns0.HostPciPassthruConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPciPassthruConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPciPassthruConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPciPassthruConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPciPassthruConfig_Def.schema - TClist = [GTD("urn:vim25","HostPciPassthruConfig",lazy=True)(pname=(ns,"HostPciPassthruConfig"), aname="_HostPciPassthruConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPciPassthruConfig = [] - return - Holder.__name__ = "ArrayOfHostPciPassthruConfig_Holder" - self.pyclass = Holder - - class HostPciPassthruInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPciPassthruInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPciPassthruInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dependentDevice"), aname="_dependentDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruEnabled"), aname="_passthruEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruCapable"), aname="_passthruCapable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"passthruActive"), aname="_passthruActive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPciPassthruInfo_Def.__bases__: - bases = list(ns0.HostPciPassthruInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPciPassthruInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPciPassthruInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPciPassthruInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPciPassthruInfo_Def.schema - TClist = [GTD("urn:vim25","HostPciPassthruInfo",lazy=True)(pname=(ns,"HostPciPassthruInfo"), aname="_HostPciPassthruInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPciPassthruInfo = [] - return - Holder.__name__ = "ArrayOfHostPciPassthruInfo_Holder" - self.pyclass = Holder - - class RefreshRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshRequestType_Holder" - self.pyclass = Holder - - class UpdatePassthruConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdatePassthruConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdatePassthruConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPciPassthruConfig",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = [] - return - Holder.__name__ = "UpdatePassthruConfigRequestType_Holder" - self.pyclass = Holder - - class PhysicalNicSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicSpec_Def.schema - TClist = [GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"linkSpeed"), aname="_linkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNicSpec_Def.__bases__: - bases = list(ns0.PhysicalNicSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNicSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PhysicalNicConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNicConfig_Def.__bases__: - bases = list(ns0.PhysicalNicConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNicConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPhysicalNicConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPhysicalNicConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPhysicalNicConfig_Def.schema - TClist = [GTD("urn:vim25","PhysicalNicConfig",lazy=True)(pname=(ns,"PhysicalNicConfig"), aname="_PhysicalNicConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PhysicalNicConfig = [] - return - Holder.__name__ = "ArrayOfPhysicalNicConfig_Holder" - self.pyclass = Holder - - class PhysicalNicLinkInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicLinkInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicLinkInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"speedMb"), aname="_speedMb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"duplex"), aname="_duplex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNicLinkInfo_Def.__bases__: - bases = list(ns0.PhysicalNicLinkInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNicLinkInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPhysicalNicLinkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPhysicalNicLinkInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPhysicalNicLinkInfo_Def.schema - TClist = [GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"PhysicalNicLinkInfo"), aname="_PhysicalNicLinkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PhysicalNicLinkInfo = [] - return - Holder.__name__ = "ArrayOfPhysicalNicLinkInfo_Holder" - self.pyclass = Holder - - class PhysicalNicHint_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicHint") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicHint_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNicHint_Def.__bases__: - bases = list(ns0.PhysicalNicHint_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNicHint_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PhysicalNicIpHint_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicIpHint") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicIpHint_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipSubnet"), aname="_ipSubnet", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PhysicalNicHint_Def not in ns0.PhysicalNicIpHint_Def.__bases__: - bases = list(ns0.PhysicalNicIpHint_Def.__bases__) - bases.insert(0, ns0.PhysicalNicHint_Def) - ns0.PhysicalNicIpHint_Def.__bases__ = tuple(bases) - - ns0.PhysicalNicHint_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPhysicalNicIpHint_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPhysicalNicIpHint") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPhysicalNicIpHint_Def.schema - TClist = [GTD("urn:vim25","PhysicalNicIpHint",lazy=True)(pname=(ns,"PhysicalNicIpHint"), aname="_PhysicalNicIpHint", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PhysicalNicIpHint = [] - return - Holder.__name__ = "ArrayOfPhysicalNicIpHint_Holder" - self.pyclass = Holder - - class PhysicalNicNameHint_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicNameHint") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicNameHint_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PhysicalNicHint_Def not in ns0.PhysicalNicNameHint_Def.__bases__: - bases = list(ns0.PhysicalNicNameHint_Def.__bases__) - bases.insert(0, ns0.PhysicalNicHint_Def) - ns0.PhysicalNicNameHint_Def.__bases__ = tuple(bases) - - ns0.PhysicalNicHint_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPhysicalNicNameHint_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPhysicalNicNameHint") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPhysicalNicNameHint_Def.schema - TClist = [GTD("urn:vim25","PhysicalNicNameHint",lazy=True)(pname=(ns,"PhysicalNicNameHint"), aname="_PhysicalNicNameHint", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PhysicalNicNameHint = [] - return - Holder.__name__ = "ArrayOfPhysicalNicNameHint_Holder" - self.pyclass = Holder - - class PhysicalNicHintInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicHintInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicHintInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicIpHint",lazy=True)(pname=(ns,"subnet"), aname="_subnet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicNameHint",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicCdpInfo",lazy=True)(pname=(ns,"connectedSwitchPort"), aname="_connectedSwitchPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNicHintInfo_Def.__bases__: - bases = list(ns0.PhysicalNicHintInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNicHintInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPhysicalNicHintInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPhysicalNicHintInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPhysicalNicHintInfo_Def.schema - TClist = [GTD("urn:vim25","PhysicalNicHintInfo",lazy=True)(pname=(ns,"PhysicalNicHintInfo"), aname="_PhysicalNicHintInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PhysicalNicHintInfo = [] - return - Holder.__name__ = "ArrayOfPhysicalNicHintInfo_Holder" - self.pyclass = Holder - - class PhysicalNicCdpDeviceCapability_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicCdpDeviceCapability") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicCdpDeviceCapability_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"router"), aname="_router", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"transparentBridge"), aname="_transparentBridge", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"sourceRouteBridge"), aname="_sourceRouteBridge", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"networkSwitch"), aname="_networkSwitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"igmpEnabled"), aname="_igmpEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"repeater"), aname="_repeater", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNicCdpDeviceCapability_Def.__bases__: - bases = list(ns0.PhysicalNicCdpDeviceCapability_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNicCdpDeviceCapability_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PhysicalNicCdpInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicCdpInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicCdpInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"cdpVersion"), aname="_cdpVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeout"), aname="_timeout", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ttl"), aname="_ttl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"samples"), aname="_samples", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devId"), aname="_devId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portId"), aname="_portId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicCdpDeviceCapability",lazy=True)(pname=(ns,"deviceCapability"), aname="_deviceCapability", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"softwareVersion"), aname="_softwareVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hardwarePlatform"), aname="_hardwarePlatform", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipPrefix"), aname="_ipPrefix", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ipPrefixLen"), aname="_ipPrefixLen", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vlan"), aname="_vlan", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"fullDuplex"), aname="_fullDuplex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemName"), aname="_systemName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemOID"), aname="_systemOID", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mgmtAddr"), aname="_mgmtAddr", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"location"), aname="_location", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNicCdpInfo_Def.__bases__: - bases = list(ns0.PhysicalNicCdpInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNicCdpInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PhysicalNic_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNic") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNic_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pci"), aname="_pci", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"driver"), aname="_driver", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"linkSpeed"), aname="_linkSpeed", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicLinkInfo",lazy=True)(pname=(ns,"validLinkSpecification"), aname="_validLinkSpecification", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"wakeOnLanSupported"), aname="_wakeOnLanSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PhysicalNic_Def.__bases__: - bases = list(ns0.PhysicalNic_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PhysicalNic_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPhysicalNic_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPhysicalNic") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPhysicalNic_Def.schema - TClist = [GTD("urn:vim25","PhysicalNic",lazy=True)(pname=(ns,"PhysicalNic"), aname="_PhysicalNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PhysicalNic = [] - return - Holder.__name__ = "ArrayOfPhysicalNic_Holder" - self.pyclass = Holder - - class HostPlugStoreTopologyAdapter_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPlugStoreTopologyAdapter") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPlugStoreTopologyAdapter_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyAdapter_Def.__bases__: - bases = list(ns0.HostPlugStoreTopologyAdapter_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPlugStoreTopologyAdapter_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPlugStoreTopologyAdapter_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPlugStoreTopologyAdapter") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPlugStoreTopologyAdapter_Def.schema - TClist = [GTD("urn:vim25","HostPlugStoreTopologyAdapter",lazy=True)(pname=(ns,"HostPlugStoreTopologyAdapter"), aname="_HostPlugStoreTopologyAdapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPlugStoreTopologyAdapter = [] - return - Holder.__name__ = "ArrayOfHostPlugStoreTopologyAdapter_Holder" - self.pyclass = Holder - - class HostPlugStoreTopologyPath_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPlugStoreTopologyPath") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPlugStoreTopologyPath_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"channelNumber"), aname="_channelNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"targetNumber"), aname="_targetNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lunNumber"), aname="_lunNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyPath_Def.__bases__: - bases = list(ns0.HostPlugStoreTopologyPath_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPlugStoreTopologyPath_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPlugStoreTopologyPath_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPlugStoreTopologyPath") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPlugStoreTopologyPath_Def.schema - TClist = [GTD("urn:vim25","HostPlugStoreTopologyPath",lazy=True)(pname=(ns,"HostPlugStoreTopologyPath"), aname="_HostPlugStoreTopologyPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPlugStoreTopologyPath = [] - return - Holder.__name__ = "ArrayOfHostPlugStoreTopologyPath_Holder" - self.pyclass = Holder - - class HostPlugStoreTopologyDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPlugStoreTopologyDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPlugStoreTopologyDevice_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyDevice_Def.__bases__: - bases = list(ns0.HostPlugStoreTopologyDevice_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPlugStoreTopologyDevice_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPlugStoreTopologyDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPlugStoreTopologyDevice") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPlugStoreTopologyDevice_Def.schema - TClist = [GTD("urn:vim25","HostPlugStoreTopologyDevice",lazy=True)(pname=(ns,"HostPlugStoreTopologyDevice"), aname="_HostPlugStoreTopologyDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPlugStoreTopologyDevice = [] - return - Holder.__name__ = "ArrayOfHostPlugStoreTopologyDevice_Holder" - self.pyclass = Holder - - class HostPlugStoreTopologyPlugin_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPlugStoreTopologyPlugin") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPlugStoreTopologyPlugin_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"claimedPath"), aname="_claimedPath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyPlugin_Def.__bases__: - bases = list(ns0.HostPlugStoreTopologyPlugin_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPlugStoreTopologyPlugin_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPlugStoreTopologyPlugin_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPlugStoreTopologyPlugin") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPlugStoreTopologyPlugin_Def.schema - TClist = [GTD("urn:vim25","HostPlugStoreTopologyPlugin",lazy=True)(pname=(ns,"HostPlugStoreTopologyPlugin"), aname="_HostPlugStoreTopologyPlugin", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPlugStoreTopologyPlugin = [] - return - Holder.__name__ = "ArrayOfHostPlugStoreTopologyPlugin_Holder" - self.pyclass = Holder - - class HostPlugStoreTopologyTarget_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPlugStoreTopologyTarget") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPlugStoreTopologyTarget_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTargetTransport",lazy=True)(pname=(ns,"transport"), aname="_transport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPlugStoreTopologyTarget_Def.__bases__: - bases = list(ns0.HostPlugStoreTopologyTarget_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPlugStoreTopologyTarget_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPlugStoreTopologyTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPlugStoreTopologyTarget") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPlugStoreTopologyTarget_Def.schema - TClist = [GTD("urn:vim25","HostPlugStoreTopologyTarget",lazy=True)(pname=(ns,"HostPlugStoreTopologyTarget"), aname="_HostPlugStoreTopologyTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPlugStoreTopologyTarget = [] - return - Holder.__name__ = "ArrayOfHostPlugStoreTopologyTarget_Holder" - self.pyclass = Holder - - class HostPlugStoreTopology_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPlugStoreTopology") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPlugStoreTopology_Def.schema - TClist = [GTD("urn:vim25","HostPlugStoreTopologyAdapter",lazy=True)(pname=(ns,"adapter"), aname="_adapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyTarget",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopologyPlugin",lazy=True)(pname=(ns,"plugin"), aname="_plugin", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPlugStoreTopology_Def.__bases__: - bases = list(ns0.HostPlugStoreTopology_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPlugStoreTopology_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PortGroupConnecteeType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "PortGroupConnecteeType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostPortGroupSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPortGroupSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPortGroupSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vlanId"), aname="_vlanId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitchName"), aname="_vswitchName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPortGroupSpec_Def.__bases__: - bases = list(ns0.HostPortGroupSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPortGroupSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostPortGroupConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPortGroupConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPortGroupConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPortGroupConfig_Def.__bases__: - bases = list(ns0.HostPortGroupConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPortGroupConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPortGroupConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPortGroupConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPortGroupConfig_Def.schema - TClist = [GTD("urn:vim25","HostPortGroupConfig",lazy=True)(pname=(ns,"HostPortGroupConfig"), aname="_HostPortGroupConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPortGroupConfig = [] - return - Holder.__name__ = "ArrayOfHostPortGroupConfig_Holder" - self.pyclass = Holder - - class HostPortGroupPort_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPortGroupPort") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPortGroupPort_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPortGroupPort_Def.__bases__: - bases = list(ns0.HostPortGroupPort_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPortGroupPort_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPortGroupPort_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPortGroupPort") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPortGroupPort_Def.schema - TClist = [GTD("urn:vim25","HostPortGroupPort",lazy=True)(pname=(ns,"HostPortGroupPort"), aname="_HostPortGroupPort", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPortGroupPort = [] - return - Holder.__name__ = "ArrayOfHostPortGroupPort_Holder" - self.pyclass = Holder - - class HostPortGroup_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPortGroup") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPortGroup_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupPort",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkPolicy",lazy=True)(pname=(ns,"computedPolicy"), aname="_computedPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostPortGroup_Def.__bases__: - bases = list(ns0.HostPortGroup_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostPortGroup_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPortGroup_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPortGroup") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPortGroup_Def.schema - TClist = [GTD("urn:vim25","HostPortGroup",lazy=True)(pname=(ns,"HostPortGroup"), aname="_HostPortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPortGroup = [] - return - Holder.__name__ = "ArrayOfHostPortGroup_Holder" - self.pyclass = Holder - - class HostResignatureRescanResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostResignatureRescanResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostResignatureRescanResult_Def.schema - TClist = [GTD("urn:vim25","HostVmfsRescanResult",lazy=True)(pname=(ns,"rescan"), aname="_rescan", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"result"), aname="_result", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostResignatureRescanResult_Def.__bases__: - bases = list(ns0.HostResignatureRescanResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostResignatureRescanResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFirewallRuleDirection_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostFirewallRuleDirection") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostFirewallRuleProtocol_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostFirewallRuleProtocol") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostFirewallRule_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFirewallRule") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFirewallRule_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"endPort"), aname="_endPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallRuleDirection",lazy=True)(pname=(ns,"direction"), aname="_direction", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"protocol"), aname="_protocol", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFirewallRule_Def.__bases__: - bases = list(ns0.HostFirewallRule_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFirewallRule_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostFirewallRule_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostFirewallRule") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostFirewallRule_Def.schema - TClist = [GTD("urn:vim25","HostFirewallRule",lazy=True)(pname=(ns,"HostFirewallRule"), aname="_HostFirewallRule", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostFirewallRule = [] - return - Holder.__name__ = "ArrayOfHostFirewallRule_Holder" - self.pyclass = Holder - - class HostFirewallRuleset_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFirewallRuleset") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFirewallRuleset_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"required"), aname="_required", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostFirewallRule",lazy=True)(pname=(ns,"rule"), aname="_rule", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostFirewallRuleset_Def.__bases__: - bases = list(ns0.HostFirewallRuleset_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostFirewallRuleset_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostFirewallRuleset_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostFirewallRuleset") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostFirewallRuleset_Def.schema - TClist = [GTD("urn:vim25","HostFirewallRuleset",lazy=True)(pname=(ns,"HostFirewallRuleset"), aname="_HostFirewallRuleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostFirewallRuleset = [] - return - Holder.__name__ = "ArrayOfHostFirewallRuleset_Holder" - self.pyclass = Holder - - class HostRuntimeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostRuntimeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostRuntimeInfo_Def.schema - TClist = [GTD("urn:vim25","HostSystemConnectionState",lazy=True)(pname=(ns,"connectionState"), aname="_connectionState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemPowerState",lazy=True)(pname=(ns,"powerState"), aname="_powerState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inMaintenanceMode"), aname="_inMaintenanceMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"bootTime"), aname="_bootTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HealthSystemRuntime",lazy=True)(pname=(ns,"healthSystemRuntime"), aname="_healthSystemRuntime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTpmDigestInfo",lazy=True)(pname=(ns,"tpmPcrValues"), aname="_tpmPcrValues", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostRuntimeInfo_Def.__bases__: - bases = list(ns0.HostRuntimeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostRuntimeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostScsiDiskPartition_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostScsiDiskPartition") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostScsiDiskPartition_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskName"), aname="_diskName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostScsiDiskPartition_Def.__bases__: - bases = list(ns0.HostScsiDiskPartition_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostScsiDiskPartition_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostScsiDiskPartition_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostScsiDiskPartition") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostScsiDiskPartition_Def.schema - TClist = [GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"HostScsiDiskPartition"), aname="_HostScsiDiskPartition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostScsiDiskPartition = [] - return - Holder.__name__ = "ArrayOfHostScsiDiskPartition_Holder" - self.pyclass = Holder - - class HostScsiDisk_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostScsiDisk") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostScsiDisk_Def.schema - TClist = [GTD("urn:vim25","HostDiskDimensionsLba",lazy=True)(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScsiLun_Def not in ns0.HostScsiDisk_Def.__bases__: - bases = list(ns0.HostScsiDisk_Def.__bases__) - bases.insert(0, ns0.ScsiLun_Def) - ns0.HostScsiDisk_Def.__bases__ = tuple(bases) - - ns0.ScsiLun_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostScsiDisk_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostScsiDisk") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostScsiDisk_Def.schema - TClist = [GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"HostScsiDisk"), aname="_HostScsiDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostScsiDisk = [] - return - Holder.__name__ = "ArrayOfHostScsiDisk_Holder" - self.pyclass = Holder - - class ScsiLunType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ScsiLunType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ScsiLunCapabilities_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScsiLunCapabilities") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScsiLunCapabilities_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"updateDisplayNameSupported"), aname="_updateDisplayNameSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ScsiLunCapabilities_Def.__bases__: - bases = list(ns0.ScsiLunCapabilities_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ScsiLunCapabilities_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScsiLunDurableName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScsiLunDurableName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScsiLunDurableName_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"namespace"), aname="_namespace", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"namespaceId"), aname="_namespaceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"data"), aname="_data", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ScsiLunDurableName_Def.__bases__: - bases = list(ns0.ScsiLunDurableName_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ScsiLunDurableName_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfScsiLunDurableName_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfScsiLunDurableName") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfScsiLunDurableName_Def.schema - TClist = [GTD("urn:vim25","ScsiLunDurableName",lazy=True)(pname=(ns,"ScsiLunDurableName"), aname="_ScsiLunDurableName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ScsiLunDurableName = [] - return - Holder.__name__ = "ArrayOfScsiLunDurableName_Holder" - self.pyclass = Holder - - class ScsiLunState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ScsiLunState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ScsiLunDescriptorQuality_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ScsiLunDescriptorQuality") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ScsiLunDescriptor_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScsiLunDescriptor") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScsiLunDescriptor_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"quality"), aname="_quality", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ScsiLunDescriptor_Def.__bases__: - bases = list(ns0.ScsiLunDescriptor_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ScsiLunDescriptor_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfScsiLunDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfScsiLunDescriptor") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfScsiLunDescriptor_Def.schema - TClist = [GTD("urn:vim25","ScsiLunDescriptor",lazy=True)(pname=(ns,"ScsiLunDescriptor"), aname="_ScsiLunDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ScsiLunDescriptor = [] - return - Holder.__name__ = "ArrayOfScsiLunDescriptor_Holder" - self.pyclass = Holder - - class ScsiLun_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScsiLun") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScsiLun_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunDescriptor",lazy=True)(pname=(ns,"descriptor"), aname="_descriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"canonicalName"), aname="_canonicalName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"displayName"), aname="_displayName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lunType"), aname="_lunType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"revision"), aname="_revision", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"scsiLevel"), aname="_scsiLevel", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"serialNumber"), aname="_serialNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunDurableName",lazy=True)(pname=(ns,"durableName"), aname="_durableName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunDurableName",lazy=True)(pname=(ns,"alternateName"), aname="_alternateName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"standardInquiry"), aname="_standardInquiry", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"queueDepth"), aname="_queueDepth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"operationalState"), aname="_operationalState", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLunCapabilities",lazy=True)(pname=(ns,"capabilities"), aname="_capabilities", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDevice_Def not in ns0.ScsiLun_Def.__bases__: - bases = list(ns0.ScsiLun_Def.__bases__) - bases.insert(0, ns0.HostDevice_Def) - ns0.ScsiLun_Def.__bases__ = tuple(bases) - - ns0.HostDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfScsiLun_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfScsiLun") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfScsiLun_Def.schema - TClist = [GTD("urn:vim25","ScsiLun",lazy=True)(pname=(ns,"ScsiLun"), aname="_ScsiLun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ScsiLun = [] - return - Holder.__name__ = "ArrayOfScsiLun_Holder" - self.pyclass = Holder - - class HostScsiTopologyInterface_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostScsiTopologyInterface") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostScsiTopologyInterface_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiTopologyTarget",lazy=True)(pname=(ns,"target"), aname="_target", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostScsiTopologyInterface_Def.__bases__: - bases = list(ns0.HostScsiTopologyInterface_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostScsiTopologyInterface_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostScsiTopologyInterface_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostScsiTopologyInterface") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostScsiTopologyInterface_Def.schema - TClist = [GTD("urn:vim25","HostScsiTopologyInterface",lazy=True)(pname=(ns,"HostScsiTopologyInterface"), aname="_HostScsiTopologyInterface", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostScsiTopologyInterface = [] - return - Holder.__name__ = "ArrayOfHostScsiTopologyInterface_Holder" - self.pyclass = Holder - - class HostScsiTopologyTarget_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostScsiTopologyTarget") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostScsiTopologyTarget_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"target"), aname="_target", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiTopologyLun",lazy=True)(pname=(ns,"lun"), aname="_lun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostTargetTransport",lazy=True)(pname=(ns,"transport"), aname="_transport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostScsiTopologyTarget_Def.__bases__: - bases = list(ns0.HostScsiTopologyTarget_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostScsiTopologyTarget_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostScsiTopologyTarget_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostScsiTopologyTarget") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostScsiTopologyTarget_Def.schema - TClist = [GTD("urn:vim25","HostScsiTopologyTarget",lazy=True)(pname=(ns,"HostScsiTopologyTarget"), aname="_HostScsiTopologyTarget", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostScsiTopologyTarget = [] - return - Holder.__name__ = "ArrayOfHostScsiTopologyTarget_Holder" - self.pyclass = Holder - - class HostScsiTopologyLun_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostScsiTopologyLun") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostScsiTopologyLun_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lun"), aname="_lun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"scsiLun"), aname="_scsiLun", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostScsiTopologyLun_Def.__bases__: - bases = list(ns0.HostScsiTopologyLun_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostScsiTopologyLun_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostScsiTopologyLun_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostScsiTopologyLun") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostScsiTopologyLun_Def.schema - TClist = [GTD("urn:vim25","HostScsiTopologyLun",lazy=True)(pname=(ns,"HostScsiTopologyLun"), aname="_HostScsiTopologyLun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostScsiTopologyLun = [] - return - Holder.__name__ = "ArrayOfHostScsiTopologyLun_Holder" - self.pyclass = Holder - - class HostScsiTopology_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostScsiTopology") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostScsiTopology_Def.schema - TClist = [GTD("urn:vim25","HostScsiTopologyInterface",lazy=True)(pname=(ns,"adapter"), aname="_adapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostScsiTopology_Def.__bases__: - bases = list(ns0.HostScsiTopology_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostScsiTopology_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostSecuritySpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSecuritySpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSecuritySpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"adminPassword"), aname="_adminPassword", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSecuritySpec_Def.__bases__: - bases = list(ns0.HostSecuritySpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSecuritySpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostServicePolicy_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostServicePolicy") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostService_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostService") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostService_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"required"), aname="_required", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uninstallable"), aname="_uninstallable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"running"), aname="_running", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ruleset"), aname="_ruleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostService_Def.__bases__: - bases = list(ns0.HostService_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostService_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostService_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostService") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostService_Def.schema - TClist = [GTD("urn:vim25","HostService",lazy=True)(pname=(ns,"HostService"), aname="_HostService", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostService = [] - return - Holder.__name__ = "ArrayOfHostService_Holder" - self.pyclass = Holder - - class HostServiceConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostServiceConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostServiceConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"serviceId"), aname="_serviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"startupPolicy"), aname="_startupPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostServiceConfig_Def.__bases__: - bases = list(ns0.HostServiceConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostServiceConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostServiceConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostServiceConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostServiceConfig_Def.schema - TClist = [GTD("urn:vim25","HostServiceConfig",lazy=True)(pname=(ns,"HostServiceConfig"), aname="_HostServiceConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostServiceConfig = [] - return - Holder.__name__ = "ArrayOfHostServiceConfig_Holder" - self.pyclass = Holder - - class HostServiceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostServiceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostServiceInfo_Def.schema - TClist = [GTD("urn:vim25","HostService",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostServiceInfo_Def.__bases__: - bases = list(ns0.HostServiceInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostServiceInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateServicePolicyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateServicePolicyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateServicePolicyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._id = None - self._policy = None - return - Holder.__name__ = "UpdateServicePolicyRequestType_Holder" - self.pyclass = Holder - - class StartServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StartServiceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StartServiceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._id = None - return - Holder.__name__ = "StartServiceRequestType_Holder" - self.pyclass = Holder - - class StopServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "StopServiceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.StopServiceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._id = None - return - Holder.__name__ = "StopServiceRequestType_Holder" - self.pyclass = Holder - - class RestartServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RestartServiceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RestartServiceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._id = None - return - Holder.__name__ = "RestartServiceRequestType_Holder" - self.pyclass = Holder - - class UninstallServiceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UninstallServiceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UninstallServiceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._id = None - return - Holder.__name__ = "UninstallServiceRequestType_Holder" - self.pyclass = Holder - - class RefreshServicesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshServicesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshServicesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshServicesRequestType_Holder" - self.pyclass = Holder - - class HostSnmpDestination_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSnmpDestination") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSnmpDestination_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"community"), aname="_community", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSnmpDestination_Def.__bases__: - bases = list(ns0.HostSnmpDestination_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSnmpDestination_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostSnmpDestination_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostSnmpDestination") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostSnmpDestination_Def.schema - TClist = [GTD("urn:vim25","HostSnmpDestination",lazy=True)(pname=(ns,"HostSnmpDestination"), aname="_HostSnmpDestination", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostSnmpDestination = [] - return - Holder.__name__ = "ArrayOfHostSnmpDestination_Holder" - self.pyclass = Holder - - class HostSnmpConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSnmpConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSnmpConfigSpec_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"readOnlyCommunities"), aname="_readOnlyCommunities", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSnmpDestination",lazy=True)(pname=(ns,"trapTargets"), aname="_trapTargets", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSnmpConfigSpec_Def.__bases__: - bases = list(ns0.HostSnmpConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSnmpConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostSnmpAgentCapability_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostSnmpAgentCapability") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostSnmpSystemAgentLimits_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSnmpSystemAgentLimits") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSnmpSystemAgentLimits_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"maxReadOnlyCommunities"), aname="_maxReadOnlyCommunities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxTrapDestinations"), aname="_maxTrapDestinations", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCommunityLength"), aname="_maxCommunityLength", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxBufferSize"), aname="_maxBufferSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSnmpAgentCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSnmpSystemAgentLimits_Def.__bases__: - bases = list(ns0.HostSnmpSystemAgentLimits_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSnmpSystemAgentLimits_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ReconfigureSnmpAgentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureSnmpAgentRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureSnmpAgentRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSnmpConfigSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "ReconfigureSnmpAgentRequestType_Holder" - self.pyclass = Holder - - class SendTestNotificationRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SendTestNotificationRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SendTestNotificationRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "SendTestNotificationRequestType_Holder" - self.pyclass = Holder - - class HostSslThumbprintInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSslThumbprintInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSslThumbprintInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"principal"), aname="_principal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprints"), aname="_sslThumbprints", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSslThumbprintInfo_Def.__bases__: - bases = list(ns0.HostSslThumbprintInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSslThumbprintInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostStorageArrayTypePolicyOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostStorageArrayTypePolicyOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostStorageArrayTypePolicyOption_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostStorageArrayTypePolicyOption_Def.__bases__: - bases = list(ns0.HostStorageArrayTypePolicyOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostStorageArrayTypePolicyOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostStorageArrayTypePolicyOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostStorageArrayTypePolicyOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostStorageArrayTypePolicyOption_Def.schema - TClist = [GTD("urn:vim25","HostStorageArrayTypePolicyOption",lazy=True)(pname=(ns,"HostStorageArrayTypePolicyOption"), aname="_HostStorageArrayTypePolicyOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostStorageArrayTypePolicyOption = [] - return - Holder.__name__ = "ArrayOfHostStorageArrayTypePolicyOption_Holder" - self.pyclass = Holder - - class HostStorageDeviceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostStorageDeviceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostStorageDeviceInfo_Def.schema - TClist = [GTD("urn:vim25","HostHostBusAdapter",lazy=True)(pname=(ns,"hostBusAdapter"), aname="_hostBusAdapter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScsiLun",lazy=True)(pname=(ns,"scsiLun"), aname="_scsiLun", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiTopology",lazy=True)(pname=(ns,"scsiTopology"), aname="_scsiTopology", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfo",lazy=True)(pname=(ns,"multipathInfo"), aname="_multipathInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPlugStoreTopology",lazy=True)(pname=(ns,"plugStoreTopology"), aname="_plugStoreTopology", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"softwareInternetScsiEnabled"), aname="_softwareInternetScsiEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostStorageDeviceInfo_Def.__bases__: - bases = list(ns0.HostStorageDeviceInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostStorageDeviceInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RetrieveDiskPartitionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveDiskPartitionInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveDiskPartitionInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._devicePath = [] - return - Holder.__name__ = "RetrieveDiskPartitionInfoRequestType_Holder" - self.pyclass = Holder - - class ComputeDiskPartitionInfoRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ComputeDiskPartitionInfoRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ComputeDiskPartitionInfoRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionLayout",lazy=True)(pname=(ns,"layout"), aname="_layout", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._devicePath = None - self._layout = None - return - Holder.__name__ = "ComputeDiskPartitionInfoRequestType_Holder" - self.pyclass = Holder - - class ComputeDiskPartitionInfoForResizeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ComputeDiskPartitionInfoForResizeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ComputeDiskPartitionInfoForResizeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionBlockRange",lazy=True)(pname=(ns,"blockRange"), aname="_blockRange", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._partition = None - self._blockRange = None - return - Holder.__name__ = "ComputeDiskPartitionInfoForResizeRequestType_Holder" - self.pyclass = Holder - - class UpdateDiskPartitionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateDiskPartitionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateDiskPartitionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostDiskPartitionSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._devicePath = None - self._spec = None - return - Holder.__name__ = "UpdateDiskPartitionsRequestType_Holder" - self.pyclass = Holder - - class FormatVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "FormatVmfsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.FormatVmfsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVmfsSpec",lazy=True)(pname=(ns,"createSpec"), aname="_createSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._createSpec = None - return - Holder.__name__ = "FormatVmfsRequestType_Holder" - self.pyclass = Holder - - class RescanVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RescanVmfsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RescanVmfsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RescanVmfsRequestType_Holder" - self.pyclass = Holder - - class AttachVmfsExtentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AttachVmfsExtentRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AttachVmfsExtentRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsPath"), aname="_vmfsPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vmfsPath = None - self._extent = None - return - Holder.__name__ = "AttachVmfsExtentRequestType_Holder" - self.pyclass = Holder - - class ExpandVmfsExtentRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ExpandVmfsExtentRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ExpandVmfsExtentRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsPath"), aname="_vmfsPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vmfsPath = None - self._extent = None - return - Holder.__name__ = "ExpandVmfsExtentRequestType_Holder" - self.pyclass = Holder - - class UpgradeVmfsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpgradeVmfsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpgradeVmfsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsPath"), aname="_vmfsPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vmfsPath = None - return - Holder.__name__ = "UpgradeVmfsRequestType_Holder" - self.pyclass = Holder - - class UpgradeVmLayoutRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpgradeVmLayoutRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpgradeVmLayoutRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "UpgradeVmLayoutRequestType_Holder" - self.pyclass = Holder - - class QueryUnresolvedVmfsVolumeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryUnresolvedVmfsVolumeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryUnresolvedVmfsVolumeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryUnresolvedVmfsVolumeRequestType_Holder" - self.pyclass = Holder - - class ResolveMultipleUnresolvedVmfsVolumesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResolveMultipleUnresolvedVmfsVolumesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostUnresolvedVmfsResolutionSpec",lazy=True)(pname=(ns,"resolutionSpec"), aname="_resolutionSpec", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._resolutionSpec = [] - return - Holder.__name__ = "ResolveMultipleUnresolvedVmfsVolumesRequestType_Holder" - self.pyclass = Holder - - class UnmountForceMountedVmfsVolumeRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UnmountForceMountedVmfsVolumeRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UnmountForceMountedVmfsVolumeRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsUuid"), aname="_vmfsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vmfsUuid = None - return - Holder.__name__ = "UnmountForceMountedVmfsVolumeRequestType_Holder" - self.pyclass = Holder - - class RescanHbaRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RescanHbaRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RescanHbaRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hbaDevice"), aname="_hbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._hbaDevice = None - return - Holder.__name__ = "RescanHbaRequestType_Holder" - self.pyclass = Holder - - class RescanAllHbaRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RescanAllHbaRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RescanAllHbaRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RescanAllHbaRequestType_Holder" - self.pyclass = Holder - - class UpdateSoftwareInternetScsiEnabledRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateSoftwareInternetScsiEnabledRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._enabled = None - return - Holder.__name__ = "UpdateSoftwareInternetScsiEnabledRequestType_Holder" - self.pyclass = Holder - - class UpdateInternetScsiDiscoveryPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateInternetScsiDiscoveryPropertiesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDiscoveryProperties",lazy=True)(pname=(ns,"discoveryProperties"), aname="_discoveryProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._discoveryProperties = None - return - Holder.__name__ = "UpdateInternetScsiDiscoveryPropertiesRequestType_Holder" - self.pyclass = Holder - - class UpdateInternetScsiAuthenticationPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateInternetScsiAuthenticationPropertiesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaAuthenticationProperties",lazy=True)(pname=(ns,"authenticationProperties"), aname="_authenticationProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaTargetSet",lazy=True)(pname=(ns,"targetSet"), aname="_targetSet", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._authenticationProperties = None - self._targetSet = None - return - Holder.__name__ = "UpdateInternetScsiAuthenticationPropertiesRequestType_Holder" - self.pyclass = Holder - - class UpdateInternetScsiDigestPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateInternetScsiDigestPropertiesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateInternetScsiDigestPropertiesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaTargetSet",lazy=True)(pname=(ns,"targetSet"), aname="_targetSet", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaDigestProperties",lazy=True)(pname=(ns,"digestProperties"), aname="_digestProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._targetSet = None - self._digestProperties = None - return - Holder.__name__ = "UpdateInternetScsiDigestPropertiesRequestType_Holder" - self.pyclass = Holder - - class UpdateInternetScsiAdvancedOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateInternetScsiAdvancedOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaTargetSet",lazy=True)(pname=(ns,"targetSet"), aname="_targetSet", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaParamValue",lazy=True)(pname=(ns,"options"), aname="_options", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._targetSet = None - self._options = [] - return - Holder.__name__ = "UpdateInternetScsiAdvancedOptionsRequestType_Holder" - self.pyclass = Holder - - class UpdateInternetScsiIPPropertiesRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateInternetScsiIPPropertiesRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateInternetScsiIPPropertiesRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaIPProperties",lazy=True)(pname=(ns,"ipProperties"), aname="_ipProperties", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._ipProperties = None - return - Holder.__name__ = "UpdateInternetScsiIPPropertiesRequestType_Holder" - self.pyclass = Holder - - class UpdateInternetScsiNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateInternetScsiNameRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateInternetScsiNameRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._iScsiName = None - return - Holder.__name__ = "UpdateInternetScsiNameRequestType_Holder" - self.pyclass = Holder - - class UpdateInternetScsiAliasRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateInternetScsiAliasRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateInternetScsiAliasRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiAlias"), aname="_iScsiAlias", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._iScsiAlias = None - return - Holder.__name__ = "UpdateInternetScsiAliasRequestType_Holder" - self.pyclass = Holder - - class AddInternetScsiSendTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddInternetScsiSendTargetsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddInternetScsiSendTargetsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._targets = [] - return - Holder.__name__ = "AddInternetScsiSendTargetsRequestType_Holder" - self.pyclass = Holder - - class RemoveInternetScsiSendTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveInternetScsiSendTargetsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveInternetScsiSendTargetsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaSendTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._targets = [] - return - Holder.__name__ = "RemoveInternetScsiSendTargetsRequestType_Holder" - self.pyclass = Holder - - class AddInternetScsiStaticTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "AddInternetScsiStaticTargetsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.AddInternetScsiStaticTargetsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._targets = [] - return - Holder.__name__ = "AddInternetScsiStaticTargetsRequestType_Holder" - self.pyclass = Holder - - class RemoveInternetScsiStaticTargetsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveInternetScsiStaticTargetsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveInternetScsiStaticTargetsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiHbaDevice"), aname="_iScsiHbaDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostInternetScsiHbaStaticTarget",lazy=True)(pname=(ns,"targets"), aname="_targets", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._iScsiHbaDevice = None - self._targets = [] - return - Holder.__name__ = "RemoveInternetScsiStaticTargetsRequestType_Holder" - self.pyclass = Holder - - class EnableMultipathPathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "EnableMultipathPathRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.EnableMultipathPathRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathName"), aname="_pathName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._pathName = None - return - Holder.__name__ = "EnableMultipathPathRequestType_Holder" - self.pyclass = Holder - - class DisableMultipathPathRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DisableMultipathPathRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DisableMultipathPathRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pathName"), aname="_pathName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._pathName = None - return - Holder.__name__ = "DisableMultipathPathRequestType_Holder" - self.pyclass = Holder - - class SetMultipathLunPolicyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SetMultipathLunPolicyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SetMultipathLunPolicyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lunId"), aname="_lunId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostMultipathInfoLogicalUnitPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._lunId = None - self._policy = None - return - Holder.__name__ = "SetMultipathLunPolicyRequestType_Holder" - self.pyclass = Holder - - class QueryPathSelectionPolicyOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryPathSelectionPolicyOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryPathSelectionPolicyOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryPathSelectionPolicyOptionsRequestType_Holder" - self.pyclass = Holder - - class QueryStorageArrayTypePolicyOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryStorageArrayTypePolicyOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "QueryStorageArrayTypePolicyOptionsRequestType_Holder" - self.pyclass = Holder - - class UpdateScsiLunDisplayNameRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateScsiLunDisplayNameRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateScsiLunDisplayNameRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lunUuid"), aname="_lunUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"displayName"), aname="_displayName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._lunUuid = None - self._displayName = None - return - Holder.__name__ = "UpdateScsiLunDisplayNameRequestType_Holder" - self.pyclass = Holder - - class RefreshStorageSystemRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RefreshStorageSystemRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RefreshStorageSystemRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RefreshStorageSystemRequestType_Holder" - self.pyclass = Holder - - class HostHardwareSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostHardwareSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostHardwareSummary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"model"), aname="_model", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemIdentificationInfo",lazy=True)(pname=(ns,"otherIdentifyingInfo"), aname="_otherIdentifyingInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memorySize"), aname="_memorySize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"cpuModel"), aname="_cpuModel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuMhz"), aname="_cpuMhz", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuPkgs"), aname="_numCpuPkgs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"numCpuThreads"), aname="_numCpuThreads", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNics"), aname="_numNics", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numHBAs"), aname="_numHBAs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostHardwareSummary_Def.__bases__: - bases = list(ns0.HostHardwareSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostHardwareSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostListSummaryQuickStats_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostListSummaryQuickStats") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostListSummaryQuickStats_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"overallCpuUsage"), aname="_overallCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"overallMemoryUsage"), aname="_overallMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedCpuFairness"), aname="_distributedCpuFairness", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedMemoryFairness"), aname="_distributedMemoryFairness", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostListSummaryQuickStats_Def.__bases__: - bases = list(ns0.HostListSummaryQuickStats_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostListSummaryQuickStats_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostConfigSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostConfigSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostConfigSummary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"sslThumbprint"), aname="_sslThumbprint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","AboutInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmotionEnabled"), aname="_vmotionEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"faultToleranceEnabled"), aname="_faultToleranceEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostConfigSummary_Def.__bases__: - bases = list(ns0.HostConfigSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostConfigSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostListSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostListSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostListSummary_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostHardwareSummary",lazy=True)(pname=(ns,"hardware"), aname="_hardware", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostRuntimeInfo",lazy=True)(pname=(ns,"runtime"), aname="_runtime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSummary",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostListSummaryQuickStats",lazy=True)(pname=(ns,"quickStats"), aname="_quickStats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"rebootRequired"), aname="_rebootRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomFieldValue",lazy=True)(pname=(ns,"customValue"), aname="_customValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"managementServerIp"), aname="_managementServerIp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"maxEVCModeKey"), aname="_maxEVCModeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"currentEVCModeKey"), aname="_currentEVCModeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostListSummary_Def.__bases__: - bases = list(ns0.HostListSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostListSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostSystemHealthInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSystemHealthInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSystemHealthInfo_Def.schema - TClist = [GTD("urn:vim25","HostNumericSensorInfo",lazy=True)(pname=(ns,"numericSensorInfo"), aname="_numericSensorInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSystemHealthInfo_Def.__bases__: - bases = list(ns0.HostSystemHealthInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSystemHealthInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostSystemIdentificationInfoIdentifier_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostSystemIdentificationInfoIdentifier") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostSystemIdentificationInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSystemIdentificationInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSystemIdentificationInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"identifierValue"), aname="_identifierValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"identifierType"), aname="_identifierType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSystemIdentificationInfo_Def.__bases__: - bases = list(ns0.HostSystemIdentificationInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSystemIdentificationInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostSystemIdentificationInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostSystemIdentificationInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostSystemIdentificationInfo_Def.schema - TClist = [GTD("urn:vim25","HostSystemIdentificationInfo",lazy=True)(pname=(ns,"HostSystemIdentificationInfo"), aname="_HostSystemIdentificationInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostSystemIdentificationInfo = [] - return - Holder.__name__ = "ArrayOfHostSystemIdentificationInfo_Holder" - self.pyclass = Holder - - class HostSystemResourceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostSystemResourceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostSystemResourceInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"child"), aname="_child", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostSystemResourceInfo_Def.__bases__: - bases = list(ns0.HostSystemResourceInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostSystemResourceInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostSystemResourceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostSystemResourceInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostSystemResourceInfo_Def.schema - TClist = [GTD("urn:vim25","HostSystemResourceInfo",lazy=True)(pname=(ns,"HostSystemResourceInfo"), aname="_HostSystemResourceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostSystemResourceInfo = [] - return - Holder.__name__ = "ArrayOfHostSystemResourceInfo_Holder" - self.pyclass = Holder - - class HostTargetTransport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostTargetTransport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostTargetTransport_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostTargetTransport_Def.__bases__: - bases = list(ns0.HostTargetTransport_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostTargetTransport_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostParallelScsiTargetTransport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostParallelScsiTargetTransport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostParallelScsiTargetTransport_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostTargetTransport_Def not in ns0.HostParallelScsiTargetTransport_Def.__bases__: - bases = list(ns0.HostParallelScsiTargetTransport_Def.__bases__) - bases.insert(0, ns0.HostTargetTransport_Def) - ns0.HostParallelScsiTargetTransport_Def.__bases__ = tuple(bases) - - ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostBlockAdapterTargetTransport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostBlockAdapterTargetTransport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostBlockAdapterTargetTransport_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostTargetTransport_Def not in ns0.HostBlockAdapterTargetTransport_Def.__bases__: - bases = list(ns0.HostBlockAdapterTargetTransport_Def.__bases__) - bases.insert(0, ns0.HostTargetTransport_Def) - ns0.HostBlockAdapterTargetTransport_Def.__bases__ = tuple(bases) - - ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostFibreChannelTargetTransport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostFibreChannelTargetTransport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostFibreChannelTargetTransport_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"portWorldWideName"), aname="_portWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"nodeWorldWideName"), aname="_nodeWorldWideName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostTargetTransport_Def not in ns0.HostFibreChannelTargetTransport_Def.__bases__: - bases = list(ns0.HostFibreChannelTargetTransport_Def.__bases__) - bases.insert(0, ns0.HostTargetTransport_Def) - ns0.HostFibreChannelTargetTransport_Def.__bases__ = tuple(bases) - - ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostInternetScsiTargetTransport_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostInternetScsiTargetTransport") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostInternetScsiTargetTransport_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"iScsiName"), aname="_iScsiName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"iScsiAlias"), aname="_iScsiAlias", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"address"), aname="_address", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostTargetTransport_Def not in ns0.HostInternetScsiTargetTransport_Def.__bases__: - bases = list(ns0.HostInternetScsiTargetTransport_Def.__bases__) - bases.insert(0, ns0.HostTargetTransport_Def) - ns0.HostInternetScsiTargetTransport_Def.__bases__ = tuple(bases) - - ns0.HostTargetTransport_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDigestInfoDigestMethodType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostDigestInfoDigestMethodType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostDigestInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDigestInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDigestInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"digestMethod"), aname="_digestMethod", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"digestValue"), aname="_digestValue", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"objectName"), aname="_objectName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDigestInfo_Def.__bases__: - bases = list(ns0.HostDigestInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDigestInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostTpmDigestInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostTpmDigestInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostTpmDigestInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"pcrNumber"), aname="_pcrNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostDigestInfo_Def not in ns0.HostTpmDigestInfo_Def.__bases__: - bases = list(ns0.HostTpmDigestInfo_Def.__bases__) - bases.insert(0, ns0.HostDigestInfo_Def) - ns0.HostTpmDigestInfo_Def.__bases__ = tuple(bases) - - ns0.HostDigestInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostTpmDigestInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostTpmDigestInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostTpmDigestInfo_Def.schema - TClist = [GTD("urn:vim25","HostTpmDigestInfo",lazy=True)(pname=(ns,"HostTpmDigestInfo"), aname="_HostTpmDigestInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostTpmDigestInfo = [] - return - Holder.__name__ = "ArrayOfHostTpmDigestInfo_Holder" - self.pyclass = Holder - - class HostUnresolvedVmfsExtentUnresolvedReason_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsExtentUnresolvedReason") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostUnresolvedVmfsExtent_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsExtent") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUnresolvedVmfsExtent_Def.schema - TClist = [GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"devicePath"), aname="_devicePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsUuid"), aname="_vmfsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"isHeadExtent"), aname="_isHeadExtent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ordinal"), aname="_ordinal", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startBlock"), aname="_startBlock", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"endBlock"), aname="_endBlock", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"reason"), aname="_reason", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsExtent_Def.__bases__: - bases = list(ns0.HostUnresolvedVmfsExtent_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostUnresolvedVmfsExtent_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostUnresolvedVmfsExtent_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostUnresolvedVmfsExtent") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostUnresolvedVmfsExtent_Def.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsExtent",lazy=True)(pname=(ns,"HostUnresolvedVmfsExtent"), aname="_HostUnresolvedVmfsExtent", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostUnresolvedVmfsExtent = [] - return - Holder.__name__ = "ArrayOfHostUnresolvedVmfsExtent_Holder" - self.pyclass = Holder - - class HostUnresolvedVmfsResignatureSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsResignatureSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUnresolvedVmfsResignatureSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"extentDevicePath"), aname="_extentDevicePath", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsResignatureSpec_Def.__bases__: - bases = list(ns0.HostUnresolvedVmfsResignatureSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostUnresolvedVmfsResignatureSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostUnresolvedVmfsResolutionResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsResolutionResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUnresolvedVmfsResolutionResult_Def.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVmfsVolume",lazy=True)(pname=(ns,"vmfs"), aname="_vmfs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsResolutionResult_Def.__bases__: - bases = list(ns0.HostUnresolvedVmfsResolutionResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostUnresolvedVmfsResolutionResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostUnresolvedVmfsResolutionResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostUnresolvedVmfsResolutionResult") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostUnresolvedVmfsResolutionResult_Def.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionResult",lazy=True)(pname=(ns,"HostUnresolvedVmfsResolutionResult"), aname="_HostUnresolvedVmfsResolutionResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostUnresolvedVmfsResolutionResult = [] - return - Holder.__name__ = "ArrayOfHostUnresolvedVmfsResolutionResult_Holder" - self.pyclass = Holder - - class HostUnresolvedVmfsResolutionSpecVmfsUuidResolution_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsResolutionSpecVmfsUuidResolution") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostUnresolvedVmfsResolutionSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsResolutionSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUnresolvedVmfsResolutionSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"extentDevicePath"), aname="_extentDevicePath", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuidResolution"), aname="_uuidResolution", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsResolutionSpec_Def.__bases__: - bases = list(ns0.HostUnresolvedVmfsResolutionSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostUnresolvedVmfsResolutionSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostUnresolvedVmfsResolutionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostUnresolvedVmfsResolutionSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostUnresolvedVmfsResolutionSpec_Def.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionSpec",lazy=True)(pname=(ns,"HostUnresolvedVmfsResolutionSpec"), aname="_HostUnresolvedVmfsResolutionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostUnresolvedVmfsResolutionSpec = [] - return - Holder.__name__ = "ArrayOfHostUnresolvedVmfsResolutionSpec_Holder" - self.pyclass = Holder - - class HostUnresolvedVmfsVolumeResolveStatus_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsVolumeResolveStatus") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"resolvable"), aname="_resolvable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"incompleteExtents"), aname="_incompleteExtents", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multipleCopies"), aname="_multipleCopies", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.__bases__: - bases = list(ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostUnresolvedVmfsVolumeResolveStatus_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostUnresolvedVmfsVolume_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostUnresolvedVmfsVolume") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostUnresolvedVmfsVolume_Def.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsExtent",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsLabel"), aname="_vmfsLabel", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmfsUuid"), aname="_vmfsUuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"totalBlocks"), aname="_totalBlocks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostUnresolvedVmfsVolumeResolveStatus",lazy=True)(pname=(ns,"resolveStatus"), aname="_resolveStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostUnresolvedVmfsVolume_Def.__bases__: - bases = list(ns0.HostUnresolvedVmfsVolume_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostUnresolvedVmfsVolume_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostUnresolvedVmfsVolume_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostUnresolvedVmfsVolume") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostUnresolvedVmfsVolume_Def.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsVolume",lazy=True)(pname=(ns,"HostUnresolvedVmfsVolume"), aname="_HostUnresolvedVmfsVolume", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostUnresolvedVmfsVolume = [] - return - Holder.__name__ = "ArrayOfHostUnresolvedVmfsVolume_Holder" - self.pyclass = Holder - - class HostVMotionConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVMotionConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVMotionConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vmotionNicKey"), aname="_vmotionNicKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVMotionConfig_Def.__bases__: - bases = list(ns0.HostVMotionConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVMotionConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVMotionInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVMotionInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVMotionInfo_Def.schema - TClist = [GTD("urn:vim25","HostVMotionNetConfig",lazy=True)(pname=(ns,"netConfig"), aname="_netConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVMotionInfo_Def.__bases__: - bases = list(ns0.HostVMotionInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVMotionInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVMotionNetConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVMotionNetConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVMotionNetConfig_Def.schema - TClist = [GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"candidateVnic"), aname="_candidateVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"selectedVnic"), aname="_selectedVnic", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVMotionNetConfig_Def.__bases__: - bases = list(ns0.HostVMotionNetConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVMotionNetConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpdateIpConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateIpConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateIpConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._ipConfig = None - return - Holder.__name__ = "UpdateIpConfigRequestType_Holder" - self.pyclass = Holder - - class SelectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "SelectVnicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.SelectVnicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._device = None - return - Holder.__name__ = "SelectVnicRequestType_Holder" - self.pyclass = Holder - - class DeselectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DeselectVnicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DeselectVnicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DeselectVnicRequestType_Holder" - self.pyclass = Holder - - class HostVirtualNicSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualNicSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualNicSpec_Def.schema - TClist = [GTD("urn:vim25","HostIpConfig",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mac"), aname="_mac", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"distributedVirtualPort"), aname="_distributedVirtualPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tsoEnabled"), aname="_tsoEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualNicSpec_Def.__bases__: - bases = list(ns0.HostVirtualNicSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualNicSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualNicConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualNicConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualNicConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualNicConfig_Def.__bases__: - bases = list(ns0.HostVirtualNicConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualNicConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostVirtualNicConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostVirtualNicConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostVirtualNicConfig_Def.schema - TClist = [GTD("urn:vim25","HostVirtualNicConfig",lazy=True)(pname=(ns,"HostVirtualNicConfig"), aname="_HostVirtualNicConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostVirtualNicConfig = [] - return - Holder.__name__ = "ArrayOfHostVirtualNicConfig_Holder" - self.pyclass = Holder - - class HostVirtualNic_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualNic") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualNic_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNicSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"port"), aname="_port", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualNic_Def.__bases__: - bases = list(ns0.HostVirtualNic_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualNic_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostVirtualNic_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostVirtualNic") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostVirtualNic_Def.schema - TClist = [GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"HostVirtualNic"), aname="_HostVirtualNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostVirtualNic = [] - return - Holder.__name__ = "ArrayOfHostVirtualNic_Holder" - self.pyclass = Holder - - class HostVirtualNicConnection_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualNicConnection") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualNicConnection_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"dvPort"), aname="_dvPort", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualNicConnection_Def.__bases__: - bases = list(ns0.HostVirtualNicConnection_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualNicConnection_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualNicManagerNicType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostVirtualNicManagerNicType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class HostVirtualNicManagerNicTypeSelection_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualNicManagerNicTypeSelection") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualNicManagerNicTypeSelection_Def.schema - TClist = [GTD("urn:vim25","HostVirtualNicConnection",lazy=True)(pname=(ns,"vnic"), aname="_vnic", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualNicManagerNicTypeSelection_Def.__bases__: - bases = list(ns0.HostVirtualNicManagerNicTypeSelection_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualNicManagerNicTypeSelection_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostVirtualNicManagerNicTypeSelection_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostVirtualNicManagerNicTypeSelection") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostVirtualNicManagerNicTypeSelection_Def.schema - TClist = [GTD("urn:vim25","HostVirtualNicManagerNicTypeSelection",lazy=True)(pname=(ns,"HostVirtualNicManagerNicTypeSelection"), aname="_HostVirtualNicManagerNicTypeSelection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostVirtualNicManagerNicTypeSelection = [] - return - Holder.__name__ = "ArrayOfHostVirtualNicManagerNicTypeSelection_Holder" - self.pyclass = Holder - - class VirtualNicManagerNetConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualNicManagerNetConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualNicManagerNetConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multiSelectAllowed"), aname="_multiSelectAllowed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualNic",lazy=True)(pname=(ns,"candidateVnic"), aname="_candidateVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"selectedVnic"), aname="_selectedVnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualNicManagerNetConfig_Def.__bases__: - bases = list(ns0.VirtualNicManagerNetConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualNicManagerNetConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualNicManagerNetConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualNicManagerNetConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualNicManagerNetConfig_Def.schema - TClist = [GTD("urn:vim25","VirtualNicManagerNetConfig",lazy=True)(pname=(ns,"VirtualNicManagerNetConfig"), aname="_VirtualNicManagerNetConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualNicManagerNetConfig = [] - return - Holder.__name__ = "ArrayOfVirtualNicManagerNetConfig_Holder" - self.pyclass = Holder - - class QueryNetConfigRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryNetConfigRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryNetConfigRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._nicType = None - return - Holder.__name__ = "QueryNetConfigRequestType_Holder" - self.pyclass = Holder - - class VirtualNicManagerSelectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualNicManagerSelectVnicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.VirtualNicManagerSelectVnicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._nicType = None - self._device = None - return - Holder.__name__ = "VirtualNicManagerSelectVnicRequestType_Holder" - self.pyclass = Holder - - class VirtualNicManagerDeselectVnicRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualNicManagerDeselectVnicRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.VirtualNicManagerDeselectVnicRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"nicType"), aname="_nicType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._nicType = None - self._device = None - return - Holder.__name__ = "VirtualNicManagerDeselectVnicRequestType_Holder" - self.pyclass = Holder - - class HostVirtualNicManagerInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualNicManagerInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualNicManagerInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualNicManagerNetConfig",lazy=True)(pname=(ns,"netConfig"), aname="_netConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualNicManagerInfo_Def.__bases__: - bases = list(ns0.HostVirtualNicManagerInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualNicManagerInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualSwitchBridge_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitchBridge") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitchBridge_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualSwitchBridge_Def.__bases__: - bases = list(ns0.HostVirtualSwitchBridge_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualSwitchBridge_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualSwitchAutoBridge_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitchAutoBridge") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitchAutoBridge_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"excludedNicDevice"), aname="_excludedNicDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostVirtualSwitchBridge_Def not in ns0.HostVirtualSwitchAutoBridge_Def.__bases__: - bases = list(ns0.HostVirtualSwitchAutoBridge_Def.__bases__) - bases.insert(0, ns0.HostVirtualSwitchBridge_Def) - ns0.HostVirtualSwitchAutoBridge_Def.__bases__ = tuple(bases) - - ns0.HostVirtualSwitchBridge_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualSwitchSimpleBridge_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitchSimpleBridge") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitchSimpleBridge_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"nicDevice"), aname="_nicDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostVirtualSwitchBridge_Def not in ns0.HostVirtualSwitchSimpleBridge_Def.__bases__: - bases = list(ns0.HostVirtualSwitchSimpleBridge_Def.__bases__) - bases.insert(0, ns0.HostVirtualSwitchBridge_Def) - ns0.HostVirtualSwitchSimpleBridge_Def.__bases__ = tuple(bases) - - ns0.HostVirtualSwitchBridge_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualSwitchBondBridge_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitchBondBridge") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitchBondBridge_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"nicDevice"), aname="_nicDevice", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchBeaconConfig",lazy=True)(pname=(ns,"beacon"), aname="_beacon", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkDiscoveryProtocolConfig",lazy=True)(pname=(ns,"linkDiscoveryProtocolConfig"), aname="_linkDiscoveryProtocolConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostVirtualSwitchBridge_Def not in ns0.HostVirtualSwitchBondBridge_Def.__bases__: - bases = list(ns0.HostVirtualSwitchBondBridge_Def.__bases__) - bases.insert(0, ns0.HostVirtualSwitchBridge_Def) - ns0.HostVirtualSwitchBondBridge_Def.__bases__ = tuple(bases) - - ns0.HostVirtualSwitchBridge_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualSwitchBeaconConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitchBeaconConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitchBeaconConfig_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualSwitchBeaconConfig_Def.__bases__: - bases = list(ns0.HostVirtualSwitchBeaconConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualSwitchBeaconConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualSwitchSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitchSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitchSpec_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchBridge",lazy=True)(pname=(ns,"bridge"), aname="_bridge", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostNetworkPolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualSwitchSpec_Def.__bases__: - bases = list(ns0.HostVirtualSwitchSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualSwitchSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVirtualSwitchConfig_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitchConfig") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitchConfig_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeOperation"), aname="_changeOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualSwitchConfig_Def.__bases__: - bases = list(ns0.HostVirtualSwitchConfig_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualSwitchConfig_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostVirtualSwitchConfig_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostVirtualSwitchConfig") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostVirtualSwitchConfig_Def.schema - TClist = [GTD("urn:vim25","HostVirtualSwitchConfig",lazy=True)(pname=(ns,"HostVirtualSwitchConfig"), aname="_HostVirtualSwitchConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostVirtualSwitchConfig = [] - return - Holder.__name__ = "ArrayOfHostVirtualSwitchConfig_Holder" - self.pyclass = Holder - - class HostVirtualSwitch_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVirtualSwitch") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVirtualSwitch_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numPortsAvailable"), aname="_numPortsAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"mtu"), aname="_mtu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"portgroup"), aname="_portgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostVirtualSwitchSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVirtualSwitch_Def.__bases__: - bases = list(ns0.HostVirtualSwitch_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVirtualSwitch_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostVirtualSwitch_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostVirtualSwitch") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostVirtualSwitch_Def.schema - TClist = [GTD("urn:vim25","HostVirtualSwitch",lazy=True)(pname=(ns,"HostVirtualSwitch"), aname="_HostVirtualSwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostVirtualSwitch = [] - return - Holder.__name__ = "ArrayOfHostVirtualSwitch_Holder" - self.pyclass = Holder - - class HostVmfsRescanResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVmfsRescanResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVmfsRescanResult_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"fault"), aname="_fault", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVmfsRescanResult_Def.__bases__: - bases = list(ns0.HostVmfsRescanResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVmfsRescanResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostVmfsRescanResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostVmfsRescanResult") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostVmfsRescanResult_Def.schema - TClist = [GTD("urn:vim25","HostVmfsRescanResult",lazy=True)(pname=(ns,"HostVmfsRescanResult"), aname="_HostVmfsRescanResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostVmfsRescanResult = [] - return - Holder.__name__ = "ArrayOfHostVmfsRescanResult_Holder" - self.pyclass = Holder - - class HostVmfsSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVmfsSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVmfsSpec_Def.schema - TClist = [GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"blockSizeMb"), aname="_blockSizeMb", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"majorVersion"), aname="_majorVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"volumeName"), aname="_volumeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostVmfsSpec_Def.__bases__: - bases = list(ns0.HostVmfsSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostVmfsSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostVmfsVolume_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostVmfsVolume") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostVmfsVolume_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"blockSizeMb"), aname="_blockSizeMb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxBlocks"), aname="_maxBlocks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"majorVersion"), aname="_majorVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostScsiDiskPartition",lazy=True)(pname=(ns,"extent"), aname="_extent", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmfsUpgradable"), aname="_vmfsUpgradable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostForceMountedInfo",lazy=True)(pname=(ns,"forceMountedInfo"), aname="_forceMountedInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostFileSystemVolume_Def not in ns0.HostVmfsVolume_Def.__bases__: - bases = list(ns0.HostVmfsVolume_Def.__bases__) - bases.insert(0, ns0.HostFileSystemVolume_Def) - ns0.HostVmfsVolume_Def.__bases__ = tuple(bases) - - ns0.HostFileSystemVolume_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayUpdateOperation_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayUpdateOperation") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ArrayUpdateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ArrayUpdateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ArrayUpdateSpec_Def.schema - TClist = [GTD("urn:vim25","ArrayUpdateOperation",lazy=True)(pname=(ns,"operation"), aname="_operation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"removeKey"), aname="_removeKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ArrayUpdateSpec_Def.__bases__: - bases = list(ns0.ArrayUpdateSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ArrayUpdateSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class BoolOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "BoolOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.BoolOption_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"supported"), aname="_supported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OptionType_Def not in ns0.BoolOption_Def.__bases__: - bases = list(ns0.BoolOption_Def.__bases__) - bases.insert(0, ns0.OptionType_Def) - ns0.BoolOption_Def.__bases__ = tuple(bases) - - ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ChoiceOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ChoiceOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ChoiceOption_Def.schema - TClist = [GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"choiceInfo"), aname="_choiceInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultIndex"), aname="_defaultIndex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OptionType_Def not in ns0.ChoiceOption_Def.__bases__: - bases = list(ns0.ChoiceOption_Def.__bases__) - bases.insert(0, ns0.OptionType_Def) - ns0.ChoiceOption_Def.__bases__ = tuple(bases) - - ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FloatOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FloatOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FloatOption_Def.schema - TClist = [ZSI.TCnumbers.FPfloat(pname=(ns,"min"), aname="_min", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OptionType_Def not in ns0.FloatOption_Def.__bases__: - bases = list(ns0.FloatOption_Def.__bases__) - bases.insert(0, ns0.OptionType_Def) - ns0.FloatOption_Def.__bases__ = tuple(bases) - - ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IntOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IntOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IntOption_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"min"), aname="_min", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OptionType_Def not in ns0.IntOption_Def.__bases__: - bases = list(ns0.IntOption_Def.__bases__) - bases.insert(0, ns0.OptionType_Def) - ns0.IntOption_Def.__bases__ = tuple(bases) - - ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class LongOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LongOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LongOption_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"min"), aname="_min", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"max"), aname="_max", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OptionType_Def not in ns0.LongOption_Def.__bases__: - bases = list(ns0.LongOption_Def.__bases__) - bases.insert(0, ns0.OptionType_Def) - ns0.LongOption_Def.__bases__ = tuple(bases) - - ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OptionDef_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OptionDef") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OptionDef_Def.schema - TClist = [GTD("urn:vim25","OptionType",lazy=True)(pname=(ns,"optionType"), aname="_optionType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ElementDescription_Def not in ns0.OptionDef_Def.__bases__: - bases = list(ns0.OptionDef_Def.__bases__) - bases.insert(0, ns0.ElementDescription_Def) - ns0.OptionDef_Def.__bases__ = tuple(bases) - - ns0.ElementDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOptionDef_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOptionDef") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOptionDef_Def.schema - TClist = [GTD("urn:vim25","OptionDef",lazy=True)(pname=(ns,"OptionDef"), aname="_OptionDef", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OptionDef = [] - return - Holder.__name__ = "ArrayOfOptionDef_Holder" - self.pyclass = Holder - - class QueryOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - return - Holder.__name__ = "QueryOptionsRequestType_Holder" - self.pyclass = Holder - - class UpdateOptionsRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpdateOptionsRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.UpdateOptionsRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"changedValue"), aname="_changedValue", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._changedValue = [] - return - Holder.__name__ = "UpdateOptionsRequestType_Holder" - self.pyclass = Holder - - class OptionType_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OptionType") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OptionType_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"valueIsReadonly"), aname="_valueIsReadonly", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OptionType_Def.__bases__: - bases = list(ns0.OptionType_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OptionType_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OptionValue_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OptionValue") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OptionValue_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.OptionValue_Def.__bases__: - bases = list(ns0.OptionValue_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.OptionValue_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOptionValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOptionValue") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOptionValue_Def.schema - TClist = [GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"OptionValue"), aname="_OptionValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OptionValue = [] - return - Holder.__name__ = "ArrayOfOptionValue_Holder" - self.pyclass = Holder - - class StringOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "StringOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.StringOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"validCharacters"), aname="_validCharacters", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.OptionType_Def not in ns0.StringOption_Def.__bases__: - bases = list(ns0.StringOption_Def.__bases__) - bases.insert(0, ns0.OptionType_Def) - ns0.StringOption_Def.__bases__ = tuple(bases) - - ns0.OptionType_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ApplyProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ApplyProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ApplyProfile_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfilePolicy",lazy=True)(pname=(ns,"policy"), aname="_policy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ApplyProfile_Def.__bases__: - bases = list(ns0.ApplyProfile_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ApplyProfile_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ComplianceLocator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComplianceLocator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComplianceLocator_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"applyPath"), aname="_applyPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ComplianceLocator_Def.__bases__: - bases = list(ns0.ComplianceLocator_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ComplianceLocator_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfComplianceLocator_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfComplianceLocator") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfComplianceLocator_Def.schema - TClist = [GTD("urn:vim25","ComplianceLocator",lazy=True)(pname=(ns,"ComplianceLocator"), aname="_ComplianceLocator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ComplianceLocator = [] - return - Holder.__name__ = "ArrayOfComplianceLocator_Holder" - self.pyclass = Holder - - class ComplianceManagerCheckComplianceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ComplianceManagerCheckComplianceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ComplianceManagerCheckComplianceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._profile = [] - self._entity = [] - return - Holder.__name__ = "ComplianceManagerCheckComplianceRequestType_Holder" - self.pyclass = Holder - - class ComplianceManagerQueryComplianceStatusRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ComplianceManagerQueryComplianceStatusRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ComplianceManagerQueryComplianceStatusRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._profile = [] - self._entity = [] - return - Holder.__name__ = "ComplianceManagerQueryComplianceStatusRequestType_Holder" - self.pyclass = Holder - - class ComplianceManagerClearComplianceStatusRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ComplianceManagerClearComplianceStatusRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ComplianceManagerClearComplianceStatusRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._profile = [] - self._entity = [] - return - Holder.__name__ = "ComplianceManagerClearComplianceStatusRequestType_Holder" - self.pyclass = Holder - - class ComplianceManagerQueryExpressionMetadataRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ComplianceManagerQueryExpressionMetadataRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._expressionName = [] - return - Holder.__name__ = "ComplianceManagerQueryExpressionMetadataRequestType_Holder" - self.pyclass = Holder - - class ComplianceProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComplianceProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComplianceProfile_Def.schema - TClist = [GTD("urn:vim25","ProfileExpression",lazy=True)(pname=(ns,"expression"), aname="_expression", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"rootExpression"), aname="_rootExpression", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ComplianceProfile_Def.__bases__: - bases = list(ns0.ComplianceProfile_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ComplianceProfile_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ComplianceResultStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ComplianceResultStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ComplianceFailure_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComplianceFailure") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComplianceFailure_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"failureType"), aname="_failureType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ComplianceFailure_Def.__bases__: - bases = list(ns0.ComplianceFailure_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ComplianceFailure_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfComplianceFailure_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfComplianceFailure") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfComplianceFailure_Def.schema - TClist = [GTD("urn:vim25","ComplianceFailure",lazy=True)(pname=(ns,"ComplianceFailure"), aname="_ComplianceFailure", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ComplianceFailure = [] - return - Holder.__name__ = "ArrayOfComplianceFailure_Holder" - self.pyclass = Holder - - class ComplianceResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ComplianceResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ComplianceResult_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"profile"), aname="_profile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"complianceStatus"), aname="_complianceStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"checkTime"), aname="_checkTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceFailure",lazy=True)(pname=(ns,"failure"), aname="_failure", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ComplianceResult_Def.__bases__: - bases = list(ns0.ComplianceResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ComplianceResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfComplianceResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfComplianceResult") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfComplianceResult_Def.schema - TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"ComplianceResult"), aname="_ComplianceResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ComplianceResult = [] - return - Holder.__name__ = "ArrayOfComplianceResult_Holder" - self.pyclass = Holder - - class ProfileDeferredPolicyOptionParameter_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileDeferredPolicyOptionParameter") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileDeferredPolicyOptionParameter_Def.schema - TClist = [GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"inputPath"), aname="_inputPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileDeferredPolicyOptionParameter_Def.__bases__: - bases = list(ns0.ProfileDeferredPolicyOptionParameter_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileDeferredPolicyOptionParameter_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileDeferredPolicyOptionParameter_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileDeferredPolicyOptionParameter") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileDeferredPolicyOptionParameter_Def.schema - TClist = [GTD("urn:vim25","ProfileDeferredPolicyOptionParameter",lazy=True)(pname=(ns,"ProfileDeferredPolicyOptionParameter"), aname="_ProfileDeferredPolicyOptionParameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileDeferredPolicyOptionParameter = [] - return - Holder.__name__ = "ArrayOfProfileDeferredPolicyOptionParameter_Holder" - self.pyclass = Holder - - class ProfileExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileExpression_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"displayName"), aname="_displayName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"negated"), aname="_negated", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileExpression_Def.__bases__: - bases = list(ns0.ProfileExpression_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileExpression_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileExpression_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileExpression") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileExpression_Def.schema - TClist = [GTD("urn:vim25","ProfileExpression",lazy=True)(pname=(ns,"ProfileExpression"), aname="_ProfileExpression", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileExpression = [] - return - Holder.__name__ = "ArrayOfProfileExpression_Holder" - self.pyclass = Holder - - class ProfileSimpleExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileSimpleExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileSimpleExpression_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"expressionType"), aname="_expressionType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileExpression_Def not in ns0.ProfileSimpleExpression_Def.__bases__: - bases = list(ns0.ProfileSimpleExpression_Def.__bases__) - bases.insert(0, ns0.ProfileExpression_Def) - ns0.ProfileSimpleExpression_Def.__bases__ = tuple(bases) - - ns0.ProfileExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileCompositeExpression_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileCompositeExpression") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileCompositeExpression_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"operator"), aname="_operator", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"expressionName"), aname="_expressionName", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileExpression_Def not in ns0.ProfileCompositeExpression_Def.__bases__: - bases = list(ns0.ProfileCompositeExpression_Def.__bases__) - bases.insert(0, ns0.ProfileExpression_Def) - ns0.ProfileCompositeExpression_Def.__bases__ = tuple(bases) - - ns0.ProfileExpression_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileExpressionMetadata_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileExpressionMetadata") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileExpressionMetadata_Def.schema - TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"expressionId"), aname="_expressionId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileExpressionMetadata_Def.__bases__: - bases = list(ns0.ProfileExpressionMetadata_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileExpressionMetadata_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileExpressionMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileExpressionMetadata") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileExpressionMetadata_Def.schema - TClist = [GTD("urn:vim25","ProfileExpressionMetadata",lazy=True)(pname=(ns,"ProfileExpressionMetadata"), aname="_ProfileExpressionMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileExpressionMetadata = [] - return - Holder.__name__ = "ArrayOfProfileExpressionMetadata_Holder" - self.pyclass = Holder - - class ProfileNumericComparator_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileNumericComparator") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ProfileParameterMetadata_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileParameterMetadata") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileParameterMetadata_Def.schema - TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"optional"), aname="_optional", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileParameterMetadata_Def.__bases__: - bases = list(ns0.ProfileParameterMetadata_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileParameterMetadata_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileParameterMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileParameterMetadata") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileParameterMetadata_Def.schema - TClist = [GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"ProfileParameterMetadata"), aname="_ProfileParameterMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileParameterMetadata = [] - return - Holder.__name__ = "ArrayOfProfileParameterMetadata_Holder" - self.pyclass = Holder - - class ProfilePolicy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfilePolicy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfilePolicy_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PolicyOption",lazy=True)(pname=(ns,"policyOption"), aname="_policyOption", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfilePolicy_Def.__bases__: - bases = list(ns0.ProfilePolicy_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfilePolicy_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfilePolicy_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfilePolicy") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfilePolicy_Def.schema - TClist = [GTD("urn:vim25","ProfilePolicy",lazy=True)(pname=(ns,"ProfilePolicy"), aname="_ProfilePolicy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfilePolicy = [] - return - Holder.__name__ = "ArrayOfProfilePolicy_Holder" - self.pyclass = Holder - - class ProfilePolicyOptionMetadata_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfilePolicyOptionMetadata") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfilePolicyOptionMetadata_Def.schema - TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfilePolicyOptionMetadata_Def.__bases__: - bases = list(ns0.ProfilePolicyOptionMetadata_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfilePolicyOptionMetadata_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfilePolicyOptionMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfilePolicyOptionMetadata") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfilePolicyOptionMetadata_Def.schema - TClist = [GTD("urn:vim25","ProfilePolicyOptionMetadata",lazy=True)(pname=(ns,"ProfilePolicyOptionMetadata"), aname="_ProfilePolicyOptionMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfilePolicyOptionMetadata = [] - return - Holder.__name__ = "ArrayOfProfilePolicyOptionMetadata_Holder" - self.pyclass = Holder - - class ProfileCompositePolicyOptionMetadata_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileCompositePolicyOptionMetadata") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileCompositePolicyOptionMetadata_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"option"), aname="_option", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfilePolicyOptionMetadata_Def not in ns0.ProfileCompositePolicyOptionMetadata_Def.__bases__: - bases = list(ns0.ProfileCompositePolicyOptionMetadata_Def.__bases__) - bases.insert(0, ns0.ProfilePolicyOptionMetadata_Def) - ns0.ProfileCompositePolicyOptionMetadata_Def.__bases__ = tuple(bases) - - ns0.ProfilePolicyOptionMetadata_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserInputRequiredParameterMetadata_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserInputRequiredParameterMetadata") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserInputRequiredParameterMetadata_Def.schema - TClist = [GTD("urn:vim25","ProfileParameterMetadata",lazy=True)(pname=(ns,"userInputParameter"), aname="_userInputParameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfilePolicyOptionMetadata_Def not in ns0.UserInputRequiredParameterMetadata_Def.__bases__: - bases = list(ns0.UserInputRequiredParameterMetadata_Def.__bases__) - bases.insert(0, ns0.ProfilePolicyOptionMetadata_Def) - ns0.UserInputRequiredParameterMetadata_Def.__bases__ = tuple(bases) - - ns0.ProfilePolicyOptionMetadata_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfilePolicyMetadata_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfilePolicyMetadata") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfilePolicyMetadata_Def.schema - TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfilePolicyOptionMetadata",lazy=True)(pname=(ns,"possibleOption"), aname="_possibleOption", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfilePolicyMetadata_Def.__bases__: - bases = list(ns0.ProfilePolicyMetadata_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfilePolicyMetadata_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfilePolicyMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfilePolicyMetadata") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfilePolicyMetadata_Def.schema - TClist = [GTD("urn:vim25","ProfilePolicyMetadata",lazy=True)(pname=(ns,"ProfilePolicyMetadata"), aname="_ProfilePolicyMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfilePolicyMetadata = [] - return - Holder.__name__ = "ArrayOfProfilePolicyMetadata_Holder" - self.pyclass = Holder - - class PolicyOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PolicyOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PolicyOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyAnyValue",lazy=True)(pname=(ns,"parameter"), aname="_parameter", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.PolicyOption_Def.__bases__: - bases = list(ns0.PolicyOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.PolicyOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPolicyOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPolicyOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPolicyOption_Def.schema - TClist = [GTD("urn:vim25","PolicyOption",lazy=True)(pname=(ns,"PolicyOption"), aname="_PolicyOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PolicyOption = [] - return - Holder.__name__ = "ArrayOfPolicyOption_Holder" - self.pyclass = Holder - - class CompositePolicyOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CompositePolicyOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CompositePolicyOption_Def.schema - TClist = [GTD("urn:vim25","PolicyOption",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PolicyOption_Def not in ns0.CompositePolicyOption_Def.__bases__: - bases = list(ns0.CompositePolicyOption_Def.__bases__) - bases.insert(0, ns0.PolicyOption_Def) - ns0.CompositePolicyOption_Def.__bases__ = tuple(bases) - - ns0.PolicyOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileCreateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileCreateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileCreateSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileCreateSpec_Def.__bases__: - bases = list(ns0.ProfileCreateSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileCreateSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileSerializedCreateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileSerializedCreateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileSerializedCreateSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"profileConfigString"), aname="_profileConfigString", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileCreateSpec_Def not in ns0.ProfileSerializedCreateSpec_Def.__bases__: - bases = list(ns0.ProfileSerializedCreateSpec_Def.__bases__) - bases.insert(0, ns0.ProfileCreateSpec_Def) - ns0.ProfileSerializedCreateSpec_Def.__bases__ = tuple(bases) - - ns0.ProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileConfigInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileConfigInfo_Def.__bases__: - bases = list(ns0.ProfileConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileDescriptionSection_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileDescriptionSection") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileDescriptionSection_Def.schema - TClist = [GTD("urn:vim25","ExtendedElementDescription",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileDescriptionSection_Def.__bases__: - bases = list(ns0.ProfileDescriptionSection_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileDescriptionSection_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileDescriptionSection_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileDescriptionSection") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileDescriptionSection_Def.schema - TClist = [GTD("urn:vim25","ProfileDescriptionSection",lazy=True)(pname=(ns,"ProfileDescriptionSection"), aname="_ProfileDescriptionSection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileDescriptionSection = [] - return - Holder.__name__ = "ArrayOfProfileDescriptionSection_Holder" - self.pyclass = Holder - - class ProfileDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileDescription_Def.schema - TClist = [GTD("urn:vim25","ProfileDescriptionSection",lazy=True)(pname=(ns,"section"), aname="_section", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileDescription_Def.__bases__: - bases = list(ns0.ProfileDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ProfileDestroyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileDestroyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ProfileDestroyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ProfileDestroyRequestType_Holder" - self.pyclass = Holder - - class ProfileAssociateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileAssociateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ProfileAssociateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = [] - return - Holder.__name__ = "ProfileAssociateRequestType_Holder" - self.pyclass = Holder - - class ProfileDissociateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileDissociateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ProfileDissociateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = [] - return - Holder.__name__ = "ProfileDissociateRequestType_Holder" - self.pyclass = Holder - - class ProfileCheckComplianceRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileCheckComplianceRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ProfileCheckComplianceRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = [] - return - Holder.__name__ = "ProfileCheckComplianceRequestType_Holder" - self.pyclass = Holder - - class ProfileExportProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileExportProfileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ProfileExportProfileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "ProfileExportProfileRequestType_Holder" - self.pyclass = Holder - - class CreateProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateProfileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateProfileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileCreateSpec",lazy=True)(pname=(ns,"createSpec"), aname="_createSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._createSpec = None - return - Holder.__name__ = "CreateProfileRequestType_Holder" - self.pyclass = Holder - - class ProfileQueryPolicyMetadataRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileQueryPolicyMetadataRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ProfileQueryPolicyMetadataRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policyName"), aname="_policyName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._policyName = [] - return - Holder.__name__ = "ProfileQueryPolicyMetadataRequestType_Holder" - self.pyclass = Holder - - class ProfileFindAssociatedProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileFindAssociatedProfileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ProfileFindAssociatedProfileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - return - Holder.__name__ = "ProfileFindAssociatedProfileRequestType_Holder" - self.pyclass = Holder - - class ProfileMetadata_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileMetadata") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileMetadata_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ExtendedDescription",lazy=True)(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileMetadata_Def.__bases__: - bases = list(ns0.ProfileMetadata_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileMetadata_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileMetadata_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileMetadata") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileMetadata_Def.schema - TClist = [GTD("urn:vim25","ProfileMetadata",lazy=True)(pname=(ns,"ProfileMetadata"), aname="_ProfileMetadata", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileMetadata = [] - return - Holder.__name__ = "ArrayOfProfileMetadata_Holder" - self.pyclass = Holder - - class ProfilePropertyPath_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfilePropertyPath") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfilePropertyPath_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"profilePath"), aname="_profilePath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"policyId"), aname="_policyId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfilePropertyPath_Def.__bases__: - bases = list(ns0.ProfilePropertyPath_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfilePropertyPath_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterProfileConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterProfileConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterProfileConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"complyProfile"), aname="_complyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileConfigInfo_Def not in ns0.ClusterProfileConfigInfo_Def.__bases__: - bases = list(ns0.ClusterProfileConfigInfo_Def.__bases__) - bases.insert(0, ns0.ProfileConfigInfo_Def) - ns0.ClusterProfileConfigInfo_Def.__bases__ = tuple(bases) - - ns0.ProfileConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterProfileCreateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterProfileCreateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterProfileCreateSpec_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileCreateSpec_Def not in ns0.ClusterProfileCreateSpec_Def.__bases__: - bases = list(ns0.ClusterProfileCreateSpec_Def.__bases__) - bases.insert(0, ns0.ProfileCreateSpec_Def) - ns0.ClusterProfileCreateSpec_Def.__bases__ = tuple(bases) - - ns0.ProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterProfileConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterProfileConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterProfileConfigSpec_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterProfileCreateSpec_Def not in ns0.ClusterProfileConfigSpec_Def.__bases__: - bases = list(ns0.ClusterProfileConfigSpec_Def.__bases__) - bases.insert(0, ns0.ClusterProfileCreateSpec_Def) - ns0.ClusterProfileConfigSpec_Def.__bases__ = tuple(bases) - - ns0.ClusterProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterProfileCompleteConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterProfileCompleteConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterProfileCompleteConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"complyProfile"), aname="_complyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterProfileConfigSpec_Def not in ns0.ClusterProfileCompleteConfigSpec_Def.__bases__: - bases = list(ns0.ClusterProfileCompleteConfigSpec_Def.__bases__) - bases.insert(0, ns0.ClusterProfileConfigSpec_Def) - ns0.ClusterProfileCompleteConfigSpec_Def.__bases__ = tuple(bases) - - ns0.ClusterProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterProfileServiceType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ClusterProfileServiceType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ClusterProfileConfigServiceCreateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ClusterProfileConfigServiceCreateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ClusterProfileConfigServiceCreateSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"serviceType"), aname="_serviceType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ClusterProfileConfigSpec_Def not in ns0.ClusterProfileConfigServiceCreateSpec_Def.__bases__: - bases = list(ns0.ClusterProfileConfigServiceCreateSpec_Def.__bases__) - bases.insert(0, ns0.ClusterProfileConfigSpec_Def) - ns0.ClusterProfileConfigServiceCreateSpec_Def.__bases__ = tuple(bases) - - ns0.ClusterProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ClusterProfileUpdateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ClusterProfileUpdateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ClusterProfileUpdateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterProfileConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - return - Holder.__name__ = "ClusterProfileUpdateRequestType_Holder" - self.pyclass = Holder - - class ProfileExecuteResultStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ProfileExecuteResultStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ProfileExecuteError_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileExecuteError") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileExecuteError_Def.schema - TClist = [GTD("urn:vim25","ProfilePropertyPath",lazy=True)(pname=(ns,"path"), aname="_path", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileExecuteError_Def.__bases__: - bases = list(ns0.ProfileExecuteError_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileExecuteError_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfProfileExecuteError_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfProfileExecuteError") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfProfileExecuteError_Def.schema - TClist = [GTD("urn:vim25","ProfileExecuteError",lazy=True)(pname=(ns,"ProfileExecuteError"), aname="_ProfileExecuteError", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ProfileExecuteError = [] - return - Holder.__name__ = "ArrayOfProfileExecuteError_Holder" - self.pyclass = Holder - - class ProfileExecuteResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ProfileExecuteResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ProfileExecuteResult_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"inapplicablePath"), aname="_inapplicablePath", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileDeferredPolicyOptionParameter",lazy=True)(pname=(ns,"requireInput"), aname="_requireInput", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileExecuteError",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ProfileExecuteResult_Def.__bases__: - bases = list(ns0.ProfileExecuteResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ProfileExecuteResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostApplyProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostApplyProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostApplyProfile_Def.schema - TClist = [GTD("urn:vim25","HostMemoryProfile",lazy=True)(pname=(ns,"memory"), aname="_memory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","StorageProfile",lazy=True)(pname=(ns,"storage"), aname="_storage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkProfile",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DateTimeProfile",lazy=True)(pname=(ns,"datetime"), aname="_datetime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FirewallProfile",lazy=True)(pname=(ns,"firewall"), aname="_firewall", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SecurityProfile",lazy=True)(pname=(ns,"security"), aname="_security", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ServiceProfile",lazy=True)(pname=(ns,"service"), aname="_service", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionProfile",lazy=True)(pname=(ns,"option"), aname="_option", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","UserProfile",lazy=True)(pname=(ns,"userAccount"), aname="_userAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","UserGroupProfile",lazy=True)(pname=(ns,"usergroupAccount"), aname="_usergroupAccount", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.HostApplyProfile_Def.__bases__: - bases = list(ns0.HostApplyProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.HostApplyProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PhysicalNicProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PhysicalNicProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PhysicalNicProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.PhysicalNicProfile_Def.__bases__: - bases = list(ns0.PhysicalNicProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.PhysicalNicProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPhysicalNicProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPhysicalNicProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPhysicalNicProfile_Def.schema - TClist = [GTD("urn:vim25","PhysicalNicProfile",lazy=True)(pname=(ns,"PhysicalNicProfile"), aname="_PhysicalNicProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PhysicalNicProfile = [] - return - Holder.__name__ = "ArrayOfPhysicalNicProfile_Holder" - self.pyclass = Holder - - class HostMemoryProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostMemoryProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostMemoryProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.HostMemoryProfile_Def.__bases__: - bases = list(ns0.HostMemoryProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.HostMemoryProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UserProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.UserProfile_Def.__bases__: - bases = list(ns0.UserProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.UserProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfUserProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfUserProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfUserProfile_Def.schema - TClist = [GTD("urn:vim25","UserProfile",lazy=True)(pname=(ns,"UserProfile"), aname="_UserProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._UserProfile = [] - return - Holder.__name__ = "ArrayOfUserProfile_Holder" - self.pyclass = Holder - - class UserGroupProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "UserGroupProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.UserGroupProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.UserGroupProfile_Def.__bases__: - bases = list(ns0.UserGroupProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.UserGroupProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfUserGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfUserGroupProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfUserGroupProfile_Def.schema - TClist = [GTD("urn:vim25","UserGroupProfile",lazy=True)(pname=(ns,"UserGroupProfile"), aname="_UserGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._UserGroupProfile = [] - return - Holder.__name__ = "ArrayOfUserGroupProfile_Holder" - self.pyclass = Holder - - class SecurityProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "SecurityProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.SecurityProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.SecurityProfile_Def.__bases__: - bases = list(ns0.SecurityProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.SecurityProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OptionProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OptionProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OptionProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.OptionProfile_Def.__bases__: - bases = list(ns0.OptionProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.OptionProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfOptionProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfOptionProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfOptionProfile_Def.schema - TClist = [GTD("urn:vim25","OptionProfile",lazy=True)(pname=(ns,"OptionProfile"), aname="_OptionProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._OptionProfile = [] - return - Holder.__name__ = "ArrayOfOptionProfile_Holder" - self.pyclass = Holder - - class DateTimeProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DateTimeProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DateTimeProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.DateTimeProfile_Def.__bases__: - bases = list(ns0.DateTimeProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.DateTimeProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ServiceProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ServiceProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ServiceProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.ServiceProfile_Def.__bases__: - bases = list(ns0.ServiceProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.ServiceProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfServiceProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfServiceProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfServiceProfile_Def.schema - TClist = [GTD("urn:vim25","ServiceProfile",lazy=True)(pname=(ns,"ServiceProfile"), aname="_ServiceProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ServiceProfile = [] - return - Holder.__name__ = "ArrayOfServiceProfile_Holder" - self.pyclass = Holder - - class FirewallProfileRulesetProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FirewallProfileRulesetProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FirewallProfileRulesetProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.FirewallProfileRulesetProfile_Def.__bases__: - bases = list(ns0.FirewallProfileRulesetProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.FirewallProfileRulesetProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfFirewallProfileRulesetProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfFirewallProfileRulesetProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfFirewallProfileRulesetProfile_Def.schema - TClist = [GTD("urn:vim25","FirewallProfileRulesetProfile",lazy=True)(pname=(ns,"FirewallProfileRulesetProfile"), aname="_FirewallProfileRulesetProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._FirewallProfileRulesetProfile = [] - return - Holder.__name__ = "ArrayOfFirewallProfileRulesetProfile_Holder" - self.pyclass = Holder - - class FirewallProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FirewallProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FirewallProfile_Def.schema - TClist = [GTD("urn:vim25","FirewallProfileRulesetProfile",lazy=True)(pname=(ns,"ruleset"), aname="_ruleset", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.FirewallProfile_Def.__bases__: - bases = list(ns0.FirewallProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.FirewallProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NasStorageProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NasStorageProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NasStorageProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.NasStorageProfile_Def.__bases__: - bases = list(ns0.NasStorageProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.NasStorageProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfNasStorageProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfNasStorageProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfNasStorageProfile_Def.schema - TClist = [GTD("urn:vim25","NasStorageProfile",lazy=True)(pname=(ns,"NasStorageProfile"), aname="_NasStorageProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._NasStorageProfile = [] - return - Holder.__name__ = "ArrayOfNasStorageProfile_Holder" - self.pyclass = Holder - - class StorageProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "StorageProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.StorageProfile_Def.schema - TClist = [GTD("urn:vim25","NasStorageProfile",lazy=True)(pname=(ns,"nasStorage"), aname="_nasStorage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.StorageProfile_Def.__bases__: - bases = list(ns0.StorageProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.StorageProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NetworkProfileDnsConfigProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworkProfileDnsConfigProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworkProfileDnsConfigProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.NetworkProfileDnsConfigProfile_Def.__bases__: - bases = list(ns0.NetworkProfileDnsConfigProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.NetworkProfileDnsConfigProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NetworkProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworkProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworkProfile_Def.schema - TClist = [GTD("urn:vim25","VirtualSwitchProfile",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmPortGroupProfile",lazy=True)(pname=(ns,"vmPortGroup"), aname="_vmPortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostPortGroupProfile",lazy=True)(pname=(ns,"hostPortGroup"), aname="_hostPortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ServiceConsolePortGroupProfile",lazy=True)(pname=(ns,"serviceConsolePortGroup"), aname="_serviceConsolePortGroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkProfileDnsConfigProfile",lazy=True)(pname=(ns,"dnsConfig"), aname="_dnsConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpRouteProfile",lazy=True)(pname=(ns,"ipRouteConfig"), aname="_ipRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpRouteProfile",lazy=True)(pname=(ns,"consoleIpRouteConfig"), aname="_consoleIpRouteConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PhysicalNicProfile",lazy=True)(pname=(ns,"pnic"), aname="_pnic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsProfile",lazy=True)(pname=(ns,"dvswitch"), aname="_dvswitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsServiceConsoleVNicProfile",lazy=True)(pname=(ns,"dvsServiceConsoleNic"), aname="_dvsServiceConsoleNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DvsHostVNicProfile",lazy=True)(pname=(ns,"dvsHostNic"), aname="_dvsHostNic", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.NetworkProfile_Def.__bases__: - bases = list(ns0.NetworkProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.NetworkProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsVNicProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsVNicProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsVNicProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpAddressProfile",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.DvsVNicProfile_Def.__bases__: - bases = list(ns0.DvsVNicProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.DvsVNicProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DvsServiceConsoleVNicProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsServiceConsoleVNicProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsServiceConsoleVNicProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsVNicProfile_Def not in ns0.DvsServiceConsoleVNicProfile_Def.__bases__: - bases = list(ns0.DvsServiceConsoleVNicProfile_Def.__bases__) - bases.insert(0, ns0.DvsVNicProfile_Def) - ns0.DvsServiceConsoleVNicProfile_Def.__bases__ = tuple(bases) - - ns0.DvsVNicProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDvsServiceConsoleVNicProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDvsServiceConsoleVNicProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDvsServiceConsoleVNicProfile_Def.schema - TClist = [GTD("urn:vim25","DvsServiceConsoleVNicProfile",lazy=True)(pname=(ns,"DvsServiceConsoleVNicProfile"), aname="_DvsServiceConsoleVNicProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DvsServiceConsoleVNicProfile = [] - return - Holder.__name__ = "ArrayOfDvsServiceConsoleVNicProfile_Holder" - self.pyclass = Holder - - class DvsHostVNicProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsHostVNicProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsHostVNicProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DvsVNicProfile_Def not in ns0.DvsHostVNicProfile_Def.__bases__: - bases = list(ns0.DvsHostVNicProfile_Def.__bases__) - bases.insert(0, ns0.DvsVNicProfile_Def) - ns0.DvsHostVNicProfile_Def.__bases__ = tuple(bases) - - ns0.DvsVNicProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDvsHostVNicProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDvsHostVNicProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDvsHostVNicProfile_Def.schema - TClist = [GTD("urn:vim25","DvsHostVNicProfile",lazy=True)(pname=(ns,"DvsHostVNicProfile"), aname="_DvsHostVNicProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DvsHostVNicProfile = [] - return - Holder.__name__ = "ArrayOfDvsHostVNicProfile_Holder" - self.pyclass = Holder - - class DvsProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DvsProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DvsProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","PnicUplinkProfile",lazy=True)(pname=(ns,"uplink"), aname="_uplink", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.DvsProfile_Def.__bases__: - bases = list(ns0.DvsProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.DvsProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfDvsProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfDvsProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfDvsProfile_Def.schema - TClist = [GTD("urn:vim25","DvsProfile",lazy=True)(pname=(ns,"DvsProfile"), aname="_DvsProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._DvsProfile = [] - return - Holder.__name__ = "ArrayOfDvsProfile_Holder" - self.pyclass = Holder - - class PnicUplinkProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PnicUplinkProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PnicUplinkProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.PnicUplinkProfile_Def.__bases__: - bases = list(ns0.PnicUplinkProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.PnicUplinkProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfPnicUplinkProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfPnicUplinkProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfPnicUplinkProfile_Def.schema - TClist = [GTD("urn:vim25","PnicUplinkProfile",lazy=True)(pname=(ns,"PnicUplinkProfile"), aname="_PnicUplinkProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._PnicUplinkProfile = [] - return - Holder.__name__ = "ArrayOfPnicUplinkProfile_Holder" - self.pyclass = Holder - - class IpRouteProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IpRouteProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IpRouteProfile_Def.schema - TClist = [GTD("urn:vim25","StaticRouteProfile",lazy=True)(pname=(ns,"staticRoute"), aname="_staticRoute", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.IpRouteProfile_Def.__bases__: - bases = list(ns0.IpRouteProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.IpRouteProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class StaticRouteProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "StaticRouteProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.StaticRouteProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.StaticRouteProfile_Def.__bases__: - bases = list(ns0.StaticRouteProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.StaticRouteProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfStaticRouteProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfStaticRouteProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfStaticRouteProfile_Def.schema - TClist = [GTD("urn:vim25","StaticRouteProfile",lazy=True)(pname=(ns,"StaticRouteProfile"), aname="_StaticRouteProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._StaticRouteProfile = [] - return - Holder.__name__ = "ArrayOfStaticRouteProfile_Holder" - self.pyclass = Holder - - class LinkProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "LinkProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.LinkProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.LinkProfile_Def.__bases__: - bases = list(ns0.LinkProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.LinkProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class NumPortsProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NumPortsProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NumPortsProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.NumPortsProfile_Def.__bases__: - bases = list(ns0.NumPortsProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.NumPortsProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSwitchProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSwitchProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSwitchProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LinkProfile",lazy=True)(pname=(ns,"link"), aname="_link", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NumPortsProfile",lazy=True)(pname=(ns,"numPorts"), aname="_numPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkPolicyProfile",lazy=True)(pname=(ns,"networkPolicy"), aname="_networkPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.VirtualSwitchProfile_Def.__bases__: - bases = list(ns0.VirtualSwitchProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.VirtualSwitchProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualSwitchProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualSwitchProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualSwitchProfile_Def.schema - TClist = [GTD("urn:vim25","VirtualSwitchProfile",lazy=True)(pname=(ns,"VirtualSwitchProfile"), aname="_VirtualSwitchProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualSwitchProfile = [] - return - Holder.__name__ = "ArrayOfVirtualSwitchProfile_Holder" - self.pyclass = Holder - - class VlanProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VlanProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VlanProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.VlanProfile_Def.__bases__: - bases = list(ns0.VlanProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.VlanProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSwitchSelectionProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSwitchSelectionProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSwitchSelectionProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.VirtualSwitchSelectionProfile_Def.__bases__: - bases = list(ns0.VirtualSwitchSelectionProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.VirtualSwitchSelectionProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class PortGroupProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "PortGroupProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.PortGroupProfile_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VlanProfile",lazy=True)(pname=(ns,"vlan"), aname="_vlan", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualSwitchSelectionProfile",lazy=True)(pname=(ns,"vswitch"), aname="_vswitch", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","NetworkPolicyProfile",lazy=True)(pname=(ns,"networkPolicy"), aname="_networkPolicy", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.PortGroupProfile_Def.__bases__: - bases = list(ns0.PortGroupProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.PortGroupProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmPortGroupProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmPortGroupProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmPortGroupProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PortGroupProfile_Def not in ns0.VmPortGroupProfile_Def.__bases__: - bases = list(ns0.VmPortGroupProfile_Def.__bases__) - bases.insert(0, ns0.PortGroupProfile_Def) - ns0.VmPortGroupProfile_Def.__bases__ = tuple(bases) - - ns0.PortGroupProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVmPortGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVmPortGroupProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVmPortGroupProfile_Def.schema - TClist = [GTD("urn:vim25","VmPortGroupProfile",lazy=True)(pname=(ns,"VmPortGroupProfile"), aname="_VmPortGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VmPortGroupProfile = [] - return - Holder.__name__ = "ArrayOfVmPortGroupProfile_Holder" - self.pyclass = Holder - - class HostPortGroupProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostPortGroupProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostPortGroupProfile_Def.schema - TClist = [GTD("urn:vim25","IpAddressProfile",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PortGroupProfile_Def not in ns0.HostPortGroupProfile_Def.__bases__: - bases = list(ns0.HostPortGroupProfile_Def.__bases__) - bases.insert(0, ns0.PortGroupProfile_Def) - ns0.HostPortGroupProfile_Def.__bases__ = tuple(bases) - - ns0.PortGroupProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostPortGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostPortGroupProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostPortGroupProfile_Def.schema - TClist = [GTD("urn:vim25","HostPortGroupProfile",lazy=True)(pname=(ns,"HostPortGroupProfile"), aname="_HostPortGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostPortGroupProfile = [] - return - Holder.__name__ = "ArrayOfHostPortGroupProfile_Holder" - self.pyclass = Holder - - class ServiceConsolePortGroupProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ServiceConsolePortGroupProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ServiceConsolePortGroupProfile_Def.schema - TClist = [GTD("urn:vim25","IpAddressProfile",lazy=True)(pname=(ns,"ipConfig"), aname="_ipConfig", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.PortGroupProfile_Def not in ns0.ServiceConsolePortGroupProfile_Def.__bases__: - bases = list(ns0.ServiceConsolePortGroupProfile_Def.__bases__) - bases.insert(0, ns0.PortGroupProfile_Def) - ns0.ServiceConsolePortGroupProfile_Def.__bases__ = tuple(bases) - - ns0.PortGroupProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfServiceConsolePortGroupProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfServiceConsolePortGroupProfile") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfServiceConsolePortGroupProfile_Def.schema - TClist = [GTD("urn:vim25","ServiceConsolePortGroupProfile",lazy=True)(pname=(ns,"ServiceConsolePortGroupProfile"), aname="_ServiceConsolePortGroupProfile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ServiceConsolePortGroupProfile = [] - return - Holder.__name__ = "ArrayOfServiceConsolePortGroupProfile_Holder" - self.pyclass = Holder - - class NetworkPolicyProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "NetworkPolicyProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.NetworkPolicyProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.NetworkPolicyProfile_Def.__bases__: - bases = list(ns0.NetworkPolicyProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.NetworkPolicyProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IpAddressProfile_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IpAddressProfile") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IpAddressProfile_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ApplyProfile_Def not in ns0.IpAddressProfile_Def.__bases__: - bases = list(ns0.IpAddressProfile_Def.__bases__) - bases.insert(0, ns0.ApplyProfile_Def) - ns0.IpAddressProfile_Def.__bases__ = tuple(bases) - - ns0.ApplyProfile_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProfileConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProfileConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProfileConfigInfo_Def.schema - TClist = [GTD("urn:vim25","HostApplyProfile",lazy=True)(pname=(ns,"applyProfile"), aname="_applyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"defaultComplyProfile"), aname="_defaultComplyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceLocator",lazy=True)(pname=(ns,"defaultComplyLocator"), aname="_defaultComplyLocator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"customComplyProfile"), aname="_customComplyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"disabledExpressionList"), aname="_disabledExpressionList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileConfigInfo_Def not in ns0.HostProfileConfigInfo_Def.__bases__: - bases = list(ns0.HostProfileConfigInfo_Def.__bases__) - bases.insert(0, ns0.ProfileConfigInfo_Def) - ns0.HostProfileConfigInfo_Def.__bases__ = tuple(bases) - - ns0.ProfileConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProfileConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProfileConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProfileConfigSpec_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ProfileCreateSpec_Def not in ns0.HostProfileConfigSpec_Def.__bases__: - bases = list(ns0.HostProfileConfigSpec_Def.__bases__) - bases.insert(0, ns0.ProfileCreateSpec_Def) - ns0.HostProfileConfigSpec_Def.__bases__ = tuple(bases) - - ns0.ProfileCreateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProfileCompleteConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProfileCompleteConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProfileCompleteConfigSpec_Def.schema - TClist = [GTD("urn:vim25","HostApplyProfile",lazy=True)(pname=(ns,"applyProfile"), aname="_applyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ComplianceProfile",lazy=True)(pname=(ns,"customComplyProfile"), aname="_customComplyProfile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"disabledExpressionListChanged"), aname="_disabledExpressionListChanged", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"disabledExpressionList"), aname="_disabledExpressionList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostProfileConfigSpec_Def not in ns0.HostProfileCompleteConfigSpec_Def.__bases__: - bases = list(ns0.HostProfileCompleteConfigSpec_Def.__bases__) - bases.insert(0, ns0.HostProfileConfigSpec_Def) - ns0.HostProfileCompleteConfigSpec_Def.__bases__ = tuple(bases) - - ns0.HostProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProfileHostBasedConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProfileHostBasedConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProfileHostBasedConfigSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HostProfileConfigSpec_Def not in ns0.HostProfileHostBasedConfigSpec_Def.__bases__: - bases = list(ns0.HostProfileHostBasedConfigSpec_Def.__bases__) - bases.insert(0, ns0.HostProfileConfigSpec_Def) - ns0.HostProfileHostBasedConfigSpec_Def.__bases__ = tuple(bases) - - ns0.HostProfileConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProfileUpdateReferenceHostRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostProfileUpdateReferenceHostRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HostProfileUpdateReferenceHostRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - return - Holder.__name__ = "HostProfileUpdateReferenceHostRequestType_Holder" - self.pyclass = Holder - - class HostProfileUpdateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostProfileUpdateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HostProfileUpdateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostProfileConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._config = None - return - Holder.__name__ = "HostProfileUpdateRequestType_Holder" - self.pyclass = Holder - - class HostProfileExecuteRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostProfileExecuteRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HostProfileExecuteRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ProfileDeferredPolicyOptionParameter",lazy=True)(pname=(ns,"deferredParam"), aname="_deferredParam", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._deferredParam = [] - return - Holder.__name__ = "HostProfileExecuteRequestType_Holder" - self.pyclass = Holder - - class HostProfileManagerConfigTaskList_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostProfileManagerConfigTaskList") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostProfileManagerConfigTaskList_Def.schema - TClist = [GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizableMessage",lazy=True)(pname=(ns,"taskDescription"), aname="_taskDescription", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostProfileManagerConfigTaskList_Def.__bases__: - bases = list(ns0.HostProfileManagerConfigTaskList_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostProfileManagerConfigTaskList_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostProfileApplyRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostProfileApplyRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HostProfileApplyRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._configSpec = None - return - Holder.__name__ = "HostProfileApplyRequestType_Holder" - self.pyclass = Holder - - class HostProfileGenerateConfigTaskListRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostProfileGenerateConfigTaskListRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HostProfileGenerateConfigTaskListRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._configSpec = None - self._host = None - return - Holder.__name__ = "HostProfileGenerateConfigTaskListRequestType_Holder" - self.pyclass = Holder - - class HostProfileQueryProfileMetadataRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostProfileQueryProfileMetadataRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HostProfileQueryProfileMetadataRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"profileName"), aname="_profileName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._profileName = [] - return - Holder.__name__ = "HostProfileQueryProfileMetadataRequestType_Holder" - self.pyclass = Holder - - class HostProfileCreateDefaultProfileRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "HostProfileCreateDefaultProfileRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.HostProfileCreateDefaultProfileRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"profileType"), aname="_profileType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._profileType = None - return - Holder.__name__ = "HostProfileCreateDefaultProfileRequestType_Holder" - self.pyclass = Holder - - class RemoveScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveScheduledTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveScheduledTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RemoveScheduledTaskRequestType_Holder" - self.pyclass = Holder - - class ReconfigureScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ReconfigureScheduledTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ReconfigureScheduledTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._spec = None - return - Holder.__name__ = "ReconfigureScheduledTaskRequestType_Holder" - self.pyclass = Holder - - class RunScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RunScheduledTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RunScheduledTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "RunScheduledTaskRequestType_Holder" - self.pyclass = Holder - - class ScheduledTaskDetail_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskDetail") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskDetail_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"frequency"), aname="_frequency", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TypeDescription_Def not in ns0.ScheduledTaskDetail_Def.__bases__: - bases = list(ns0.ScheduledTaskDetail_Def.__bases__) - bases.insert(0, ns0.TypeDescription_Def) - ns0.ScheduledTaskDetail_Def.__bases__ = tuple(bases) - - ns0.TypeDescription_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfScheduledTaskDetail_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfScheduledTaskDetail") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfScheduledTaskDetail_Def.schema - TClist = [GTD("urn:vim25","ScheduledTaskDetail",lazy=True)(pname=(ns,"ScheduledTaskDetail"), aname="_ScheduledTaskDetail", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ScheduledTaskDetail = [] - return - Holder.__name__ = "ArrayOfScheduledTaskDetail_Holder" - self.pyclass = Holder - - class ScheduledTaskDescription_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskDescription") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskDescription_Def.schema - TClist = [GTD("urn:vim25","TypeDescription",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskDetail",lazy=True)(pname=(ns,"schedulerInfo"), aname="_schedulerInfo", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"dayOfWeek"), aname="_dayOfWeek", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ElementDescription",lazy=True)(pname=(ns,"weekOfMonth"), aname="_weekOfMonth", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ScheduledTaskDescription_Def.__bases__: - bases = list(ns0.ScheduledTaskDescription_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ScheduledTaskDescription_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"scheduledTask"), aname="_scheduledTask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"lastModifiedTime"), aname="_lastModifiedTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"lastModifiedUser"), aname="_lastModifiedUser", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"nextRunTime"), aname="_nextRunTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"prevRunTime"), aname="_prevRunTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskInfoState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"result"), aname="_result", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"progress"), aname="_progress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"activeTask"), aname="_activeTask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"taskObject"), aname="_taskObject", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ScheduledTaskSpec_Def not in ns0.ScheduledTaskInfo_Def.__bases__: - bases = list(ns0.ScheduledTaskInfo_Def.__bases__) - bases.insert(0, ns0.ScheduledTaskSpec_Def) - ns0.ScheduledTaskInfo_Def.__bases__ = tuple(bases) - - ns0.ScheduledTaskSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CreateScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateScheduledTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateScheduledTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - self._spec = None - return - Holder.__name__ = "CreateScheduledTaskRequestType_Holder" - self.pyclass = Holder - - class RetrieveEntityScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveEntityScheduledTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveEntityScheduledTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = None - return - Holder.__name__ = "RetrieveEntityScheduledTaskRequestType_Holder" - self.pyclass = Holder - - class CreateObjectScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateObjectScheduledTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateObjectScheduledTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ScheduledTaskSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._obj = None - self._spec = None - return - Holder.__name__ = "CreateObjectScheduledTaskRequestType_Holder" - self.pyclass = Holder - - class RetrieveObjectScheduledTaskRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RetrieveObjectScheduledTaskRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RetrieveObjectScheduledTaskRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._obj = None - return - Holder.__name__ = "RetrieveObjectScheduledTaskRequestType_Holder" - self.pyclass = Holder - - class TaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "TaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.TaskScheduler_Def.schema - TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"activeTime"), aname="_activeTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"expireTime"), aname="_expireTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.TaskScheduler_Def.__bases__: - bases = list(ns0.TaskScheduler_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.TaskScheduler_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class AfterStartupTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "AfterStartupTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.AfterStartupTaskScheduler_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"minute"), aname="_minute", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskScheduler_Def not in ns0.AfterStartupTaskScheduler_Def.__bases__: - bases = list(ns0.AfterStartupTaskScheduler_Def.__bases__) - bases.insert(0, ns0.TaskScheduler_Def) - ns0.AfterStartupTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.TaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class OnceTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "OnceTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.OnceTaskScheduler_Def.schema - TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"runAt"), aname="_runAt", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskScheduler_Def not in ns0.OnceTaskScheduler_Def.__bases__: - bases = list(ns0.OnceTaskScheduler_Def.__bases__) - bases.insert(0, ns0.TaskScheduler_Def) - ns0.OnceTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.TaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class RecurrentTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "RecurrentTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.RecurrentTaskScheduler_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"interval"), aname="_interval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.TaskScheduler_Def not in ns0.RecurrentTaskScheduler_Def.__bases__: - bases = list(ns0.RecurrentTaskScheduler_Def.__bases__) - bases.insert(0, ns0.TaskScheduler_Def) - ns0.RecurrentTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.TaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HourlyTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HourlyTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HourlyTaskScheduler_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"minute"), aname="_minute", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.RecurrentTaskScheduler_Def not in ns0.HourlyTaskScheduler_Def.__bases__: - bases = list(ns0.HourlyTaskScheduler_Def.__bases__) - bases.insert(0, ns0.RecurrentTaskScheduler_Def) - ns0.HourlyTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.RecurrentTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DailyTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DailyTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DailyTaskScheduler_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"hour"), aname="_hour", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.HourlyTaskScheduler_Def not in ns0.DailyTaskScheduler_Def.__bases__: - bases = list(ns0.DailyTaskScheduler_Def.__bases__) - bases.insert(0, ns0.HourlyTaskScheduler_Def) - ns0.DailyTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.HourlyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class WeeklyTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "WeeklyTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.WeeklyTaskScheduler_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"sunday"), aname="_sunday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"monday"), aname="_monday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"tuesday"), aname="_tuesday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"wednesday"), aname="_wednesday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thursday"), aname="_thursday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"friday"), aname="_friday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"saturday"), aname="_saturday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DailyTaskScheduler_Def not in ns0.WeeklyTaskScheduler_Def.__bases__: - bases = list(ns0.WeeklyTaskScheduler_Def.__bases__) - bases.insert(0, ns0.DailyTaskScheduler_Def) - ns0.WeeklyTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.DailyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MonthlyTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MonthlyTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MonthlyTaskScheduler_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DailyTaskScheduler_Def not in ns0.MonthlyTaskScheduler_Def.__bases__: - bases = list(ns0.MonthlyTaskScheduler_Def.__bases__) - bases.insert(0, ns0.DailyTaskScheduler_Def) - ns0.MonthlyTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.DailyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class MonthlyByDayTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MonthlyByDayTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MonthlyByDayTaskScheduler_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"day"), aname="_day", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MonthlyTaskScheduler_Def not in ns0.MonthlyByDayTaskScheduler_Def.__bases__: - bases = list(ns0.MonthlyByDayTaskScheduler_Def.__bases__) - bases.insert(0, ns0.MonthlyTaskScheduler_Def) - ns0.MonthlyByDayTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.MonthlyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class DayOfWeek_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DayOfWeek") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class WeekOfMonth_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "WeekOfMonth") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class MonthlyByWeekdayTaskScheduler_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "MonthlyByWeekdayTaskScheduler") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.MonthlyByWeekdayTaskScheduler_Def.schema - TClist = [GTD("urn:vim25","WeekOfMonth",lazy=True)(pname=(ns,"offset"), aname="_offset", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DayOfWeek",lazy=True)(pname=(ns,"weekday"), aname="_weekday", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.MonthlyTaskScheduler_Def not in ns0.MonthlyByWeekdayTaskScheduler_Def.__bases__: - bases = list(ns0.MonthlyByWeekdayTaskScheduler_Def.__bases__) - bases.insert(0, ns0.MonthlyTaskScheduler_Def) - ns0.MonthlyByWeekdayTaskScheduler_Def.__bases__ = tuple(bases) - - ns0.MonthlyTaskScheduler_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ScheduledTaskSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ScheduledTaskSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ScheduledTaskSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","TaskScheduler",lazy=True)(pname=(ns,"scheduler"), aname="_scheduler", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Action",lazy=True)(pname=(ns,"action"), aname="_action", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"notification"), aname="_notification", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ScheduledTaskSpec_Def.__bases__: - bases = list(ns0.ScheduledTaskSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ScheduledTaskSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppCloneSpecNetworkMappingPair_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppCloneSpecNetworkMappingPair") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppCloneSpecNetworkMappingPair_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"source"), aname="_source", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"destination"), aname="_destination", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VAppCloneSpecNetworkMappingPair_Def.__bases__: - bases = list(ns0.VAppCloneSpecNetworkMappingPair_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VAppCloneSpecNetworkMappingPair_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppCloneSpecNetworkMappingPair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppCloneSpecNetworkMappingPair") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppCloneSpecNetworkMappingPair_Def.schema - TClist = [GTD("urn:vim25","VAppCloneSpecNetworkMappingPair",lazy=True)(pname=(ns,"VAppCloneSpecNetworkMappingPair"), aname="_VAppCloneSpecNetworkMappingPair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppCloneSpecNetworkMappingPair = [] - return - Holder.__name__ = "ArrayOfVAppCloneSpecNetworkMappingPair_Holder" - self.pyclass = Holder - - class VAppCloneSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppCloneSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppCloneSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"location"), aname="_location", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"resourceSpec"), aname="_resourceSpec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vmFolder"), aname="_vmFolder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppCloneSpecNetworkMappingPair",lazy=True)(pname=(ns,"networkMapping"), aname="_networkMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","KeyValue",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VAppCloneSpec_Def.__bases__: - bases = list(ns0.VAppCloneSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VAppCloneSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppAutoStartAction_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VAppAutoStartAction") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VAppEntityConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppEntityConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppEntityConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"tag"), aname="_tag", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startOrder"), aname="_startOrder", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"startDelay"), aname="_startDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"waitingForGuest"), aname="_waitingForGuest", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"startAction"), aname="_startAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"stopDelay"), aname="_stopDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"stopAction"), aname="_stopAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VAppEntityConfigInfo_Def.__bases__: - bases = list(ns0.VAppEntityConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VAppEntityConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppEntityConfigInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppEntityConfigInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppEntityConfigInfo_Def.schema - TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"VAppEntityConfigInfo"), aname="_VAppEntityConfigInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppEntityConfigInfo = [] - return - Holder.__name__ = "ArrayOfVAppEntityConfigInfo_Holder" - self.pyclass = Holder - - class VAppIPAssignmentInfoIpAllocationPolicy_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VAppIPAssignmentInfoIpAllocationPolicy") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VAppIPAssignmentInfoAllocationSchemes_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VAppIPAssignmentInfoAllocationSchemes") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VAppIPAssignmentInfoProtocols_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VAppIPAssignmentInfoProtocols") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VAppIPAssignmentInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppIPAssignmentInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppIPAssignmentInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"supportedAllocationScheme"), aname="_supportedAllocationScheme", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAllocationPolicy"), aname="_ipAllocationPolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedIpProtocol"), aname="_supportedIpProtocol", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipProtocol"), aname="_ipProtocol", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VAppIPAssignmentInfo_Def.__bases__: - bases = list(ns0.VAppIPAssignmentInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VAppIPAssignmentInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IpPoolIpPoolConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IpPoolIpPoolConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IpPoolIpPoolConfigInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"subnetAddress"), aname="_subnetAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"netmask"), aname="_netmask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"range"), aname="_range", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dns"), aname="_dns", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"dhcpServerAvailable"), aname="_dhcpServerAvailable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ipPoolEnabled"), aname="_ipPoolEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.IpPoolIpPoolConfigInfo_Def.__bases__: - bases = list(ns0.IpPoolIpPoolConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.IpPoolIpPoolConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class IpPoolAssociation_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IpPoolAssociation") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IpPoolAssociation_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"networkName"), aname="_networkName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.IpPoolAssociation_Def.__bases__: - bases = list(ns0.IpPoolAssociation_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.IpPoolAssociation_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfIpPoolAssociation_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfIpPoolAssociation") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfIpPoolAssociation_Def.schema - TClist = [GTD("urn:vim25","IpPoolAssociation",lazy=True)(pname=(ns,"IpPoolAssociation"), aname="_IpPoolAssociation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._IpPoolAssociation = [] - return - Holder.__name__ = "ArrayOfIpPoolAssociation_Holder" - self.pyclass = Holder - - class IpPool_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "IpPool") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.IpPool_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPoolIpPoolConfigInfo",lazy=True)(pname=(ns,"ipv4Config"), aname="_ipv4Config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPoolIpPoolConfigInfo",lazy=True)(pname=(ns,"ipv6Config"), aname="_ipv6Config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsDomain"), aname="_dnsDomain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsSearchPath"), aname="_dnsSearchPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostPrefix"), aname="_hostPrefix", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"httpProxy"), aname="_httpProxy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IpPoolAssociation",lazy=True)(pname=(ns,"networkAssociation"), aname="_networkAssociation", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.IpPool_Def.__bases__: - bases = list(ns0.IpPool_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.IpPool_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfIpPool_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfIpPool") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfIpPool_Def.schema - TClist = [GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"IpPool"), aname="_IpPool", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._IpPool = [] - return - Holder.__name__ = "ArrayOfIpPool_Holder" - self.pyclass = Holder - - class VAppOvfSectionInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppOvfSectionInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppOvfSectionInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"namespace"), aname="_namespace", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"atEnvelopeLevel"), aname="_atEnvelopeLevel", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contents"), aname="_contents", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VAppOvfSectionInfo_Def.__bases__: - bases = list(ns0.VAppOvfSectionInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VAppOvfSectionInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppOvfSectionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppOvfSectionInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppOvfSectionInfo_Def.schema - TClist = [GTD("urn:vim25","VAppOvfSectionInfo",lazy=True)(pname=(ns,"VAppOvfSectionInfo"), aname="_VAppOvfSectionInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppOvfSectionInfo = [] - return - Holder.__name__ = "ArrayOfVAppOvfSectionInfo_Holder" - self.pyclass = Holder - - class VAppProductInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppProductInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppProductInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"classId"), aname="_classId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullVersion"), aname="_fullVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendorUrl"), aname="_vendorUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productUrl"), aname="_productUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"appUrl"), aname="_appUrl", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VAppProductInfo_Def.__bases__: - bases = list(ns0.VAppProductInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VAppProductInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppProductInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppProductInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppProductInfo_Def.schema - TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"VAppProductInfo"), aname="_VAppProductInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppProductInfo = [] - return - Holder.__name__ = "ArrayOfVAppProductInfo_Holder" - self.pyclass = Holder - - class VAppPropertyInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppPropertyInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppPropertyInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"classId"), aname="_classId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceId"), aname="_instanceId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"category"), aname="_category", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"label"), aname="_label", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"userConfigurable"), aname="_userConfigurable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultValue"), aname="_defaultValue", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VAppPropertyInfo_Def.__bases__: - bases = list(ns0.VAppPropertyInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VAppPropertyInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppPropertyInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppPropertyInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppPropertyInfo_Def.schema - TClist = [GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"VAppPropertyInfo"), aname="_VAppPropertyInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppPropertyInfo = [] - return - Holder.__name__ = "ArrayOfVAppPropertyInfo_Holder" - self.pyclass = Holder - - class VAppConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppConfigInfo_Def.schema - TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"entityConfig"), aname="_entityConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigInfo_Def not in ns0.VAppConfigInfo_Def.__bases__: - bases = list(ns0.VAppConfigInfo_Def.__bases__) - bases.insert(0, ns0.VmConfigInfo_Def) - ns0.VAppConfigInfo_Def.__bases__ = tuple(bases) - - ns0.VmConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppConfigSpec_Def.schema - TClist = [GTD("urn:vim25","VAppEntityConfigInfo",lazy=True)(pname=(ns,"entityConfig"), aname="_entityConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VmConfigSpec_Def not in ns0.VAppConfigSpec_Def.__bases__: - bases = list(ns0.VAppConfigSpec_Def.__bases__) - bases.insert(0, ns0.VmConfigSpec_Def) - ns0.VAppConfigSpec_Def.__bases__ = tuple(bases) - - ns0.VmConfigSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualAppImportSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualAppImportSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualAppImportSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppConfigSpec",lazy=True)(pname=(ns,"vAppConfigSpec"), aname="_vAppConfigSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceConfigSpec",lazy=True)(pname=(ns,"resourcePoolSpec"), aname="_resourcePoolSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ImportSpec",lazy=True)(pname=(ns,"child"), aname="_child", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ImportSpec_Def not in ns0.VirtualAppImportSpec_Def.__bases__: - bases = list(ns0.VirtualAppImportSpec_Def.__bases__) - bases.insert(0, ns0.ImportSpec_Def) - ns0.VirtualAppImportSpec_Def.__bases__ = tuple(bases) - - ns0.ImportSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigInfo_Def.schema - TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppIPAssignmentInfo",lazy=True)(pname=(ns,"ipAssignment"), aname="_ipAssignment", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eula"), aname="_eula", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppOvfSectionInfo",lazy=True)(pname=(ns,"ovfSection"), aname="_ovfSection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfEnvironmentTransport"), aname="_ovfEnvironmentTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"installBootStopDelay"), aname="_installBootStopDelay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmConfigInfo_Def.__bases__: - bases = list(ns0.VmConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VmConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VmConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VmConfigSpec_Def.schema - TClist = [GTD("urn:vim25","VAppProductSpec",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppPropertySpec",lazy=True)(pname=(ns,"property"), aname="_property", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppIPAssignmentInfo",lazy=True)(pname=(ns,"ipAssignment"), aname="_ipAssignment", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"eula"), aname="_eula", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppOvfSectionSpec",lazy=True)(pname=(ns,"ovfSection"), aname="_ovfSection", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ovfEnvironmentTransport"), aname="_ovfEnvironmentTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"installBootStopDelay"), aname="_installBootStopDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VmConfigSpec_Def.__bases__: - bases = list(ns0.VmConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VmConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VAppProductSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppProductSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppProductSpec_Def.schema - TClist = [GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.VAppProductSpec_Def.__bases__: - bases = list(ns0.VAppProductSpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.VAppProductSpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppProductSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppProductSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppProductSpec_Def.schema - TClist = [GTD("urn:vim25","VAppProductSpec",lazy=True)(pname=(ns,"VAppProductSpec"), aname="_VAppProductSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppProductSpec = [] - return - Holder.__name__ = "ArrayOfVAppProductSpec_Holder" - self.pyclass = Holder - - class VAppPropertySpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppPropertySpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppPropertySpec_Def.schema - TClist = [GTD("urn:vim25","VAppPropertyInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.VAppPropertySpec_Def.__bases__: - bases = list(ns0.VAppPropertySpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.VAppPropertySpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppPropertySpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppPropertySpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppPropertySpec_Def.schema - TClist = [GTD("urn:vim25","VAppPropertySpec",lazy=True)(pname=(ns,"VAppPropertySpec"), aname="_VAppPropertySpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppPropertySpec = [] - return - Holder.__name__ = "ArrayOfVAppPropertySpec_Holder" - self.pyclass = Holder - - class VAppOvfSectionSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VAppOvfSectionSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VAppOvfSectionSpec_Def.schema - TClist = [GTD("urn:vim25","VAppOvfSectionInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.VAppOvfSectionSpec_Def.__bases__: - bases = list(ns0.VAppOvfSectionSpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.VAppOvfSectionSpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVAppOvfSectionSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVAppOvfSectionSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVAppOvfSectionSpec_Def.schema - TClist = [GTD("urn:vim25","VAppOvfSectionSpec",lazy=True)(pname=(ns,"VAppOvfSectionSpec"), aname="_VAppOvfSectionSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VAppOvfSectionSpec = [] - return - Holder.__name__ = "ArrayOfVAppOvfSectionSpec_Holder" - self.pyclass = Holder - - class OpenInventoryViewFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "OpenInventoryViewFolderRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.OpenInventoryViewFolderRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = [] - return - Holder.__name__ = "OpenInventoryViewFolderRequestType_Holder" - self.pyclass = Holder - - class CloseInventoryViewFolderRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CloseInventoryViewFolderRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CloseInventoryViewFolderRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"entity"), aname="_entity", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._entity = [] - return - Holder.__name__ = "CloseInventoryViewFolderRequestType_Holder" - self.pyclass = Holder - - class ModifyListViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ModifyListViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ModifyListViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"add"), aname="_add", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"remove"), aname="_remove", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._add = [] - self._remove = [] - return - Holder.__name__ = "ModifyListViewRequestType_Holder" - self.pyclass = Holder - - class ResetListViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetListViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetListViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._obj = [] - return - Holder.__name__ = "ResetListViewRequestType_Holder" - self.pyclass = Holder - - class ResetListViewFromViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ResetListViewFromViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ResetListViewFromViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"view"), aname="_view", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._view = None - return - Holder.__name__ = "ResetListViewFromViewRequestType_Holder" - self.pyclass = Holder - - class DestroyViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "DestroyViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.DestroyViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "DestroyViewRequestType_Holder" - self.pyclass = Holder - - class CreateInventoryViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateInventoryViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateInventoryViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - return - Holder.__name__ = "CreateInventoryViewRequestType_Holder" - self.pyclass = Holder - - class CreateContainerViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateContainerViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateContainerViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"container"), aname="_container", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recursive"), aname="_recursive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._container = None - self._type = [] - self._recursive = None - return - Holder.__name__ = "CreateContainerViewRequestType_Holder" - self.pyclass = Holder - - class CreateListViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateListViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateListViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"obj"), aname="_obj", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._obj = [] - return - Holder.__name__ = "CreateListViewRequestType_Holder" - self.pyclass = Holder - - class CreateListViewFromViewRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CreateListViewFromViewRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CreateListViewFromViewRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"view"), aname="_view", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._view = None - return - Holder.__name__ = "CreateListViewFromViewRequestType_Holder" - self.pyclass = Holder - - class VirtualMachineAffinityInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineAffinityInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineAffinityInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"affinitySet"), aname="_affinitySet", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineAffinityInfo_Def.__bases__: - bases = list(ns0.VirtualMachineAffinityInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineAffinityInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineBootOptions_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineBootOptions") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineBootOptions_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"bootDelay"), aname="_bootDelay", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enterBIOSSetup"), aname="_enterBIOSSetup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineBootOptions_Def.__bases__: - bases = list(ns0.VirtualMachineBootOptions_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineBootOptions_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineCapability_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineCapability") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineCapability_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"snapshotOperationsSupported"), aname="_snapshotOperationsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"multipleSnapshotsSupported"), aname="_multipleSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"snapshotConfigSupported"), aname="_snapshotConfigSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"poweredOffSnapshotsSupported"), aname="_poweredOffSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memorySnapshotsSupported"), aname="_memorySnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"revertToSnapshotSupported"), aname="_revertToSnapshotSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"quiescedSnapshotsSupported"), aname="_quiescedSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"disableSnapshotsSupported"), aname="_disableSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"lockSnapshotsSupported"), aname="_lockSnapshotsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"consolePreferencesSupported"), aname="_consolePreferencesSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuFeatureMaskSupported"), aname="_cpuFeatureMaskSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"s1AcpiManagementSupported"), aname="_s1AcpiManagementSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"settingScreenResolutionSupported"), aname="_settingScreenResolutionSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"toolsAutoUpdateSupported"), aname="_toolsAutoUpdateSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmNpivWwnSupported"), aname="_vmNpivWwnSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivWwnOnNonRdmVmSupported"), aname="_npivWwnOnNonRdmVmSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmNpivWwnDisableSupported"), aname="_vmNpivWwnDisableSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vmNpivWwnUpdateSupported"), aname="_vmNpivWwnUpdateSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"swapPlacementSupported"), aname="_swapPlacementSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"toolsSyncTimeSupported"), aname="_toolsSyncTimeSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"virtualMmuUsageSupported"), aname="_virtualMmuUsageSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"diskSharesSupported"), aname="_diskSharesSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"bootOptionsSupported"), aname="_bootOptionsSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"settingVideoRamSizeSupported"), aname="_settingVideoRamSizeSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"settingDisplayTopologySupported"), aname="_settingDisplayTopologySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recordReplaySupported"), aname="_recordReplaySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"changeTrackingSupported"), aname="_changeTrackingSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineCapability_Def.__bases__: - bases = list(ns0.VirtualMachineCapability_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineCapability_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineCdromInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineCdromInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineCdromInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineCdromInfo_Def.__bases__: - bases = list(ns0.VirtualMachineCdromInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineCdromInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineCdromInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineCdromInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineCdromInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineCdromInfo",lazy=True)(pname=(ns,"VirtualMachineCdromInfo"), aname="_VirtualMachineCdromInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineCdromInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineCdromInfo_Holder" - self.pyclass = Holder - - class VirtualMachineCloneSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineCloneSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineCloneSpec_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineRelocateSpec",lazy=True)(pname=(ns,"location"), aname="_location", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSpec",lazy=True)(pname=(ns,"customization"), aname="_customization", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"powerOn"), aname="_powerOn", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineCloneSpec_Def.__bases__: - bases = list(ns0.VirtualMachineCloneSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineCloneSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineConfigInfoNpivWwnType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigInfoNpivWwnType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineConfigInfoSwapPlacementType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigInfoSwapPlacementType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineConfigInfoDatastoreUrlPair_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigInfoDatastoreUrlPair") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"url"), aname="_url", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.__bases__: - bases = list(ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineConfigInfoDatastoreUrlPair_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineConfigInfoDatastoreUrlPair_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineConfigInfoDatastoreUrlPair") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineConfigInfoDatastoreUrlPair_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineConfigInfoDatastoreUrlPair",lazy=True)(pname=(ns,"VirtualMachineConfigInfoDatastoreUrlPair"), aname="_VirtualMachineConfigInfoDatastoreUrlPair", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineConfigInfoDatastoreUrlPair = [] - return - Holder.__name__ = "ArrayOfVirtualMachineConfigInfoDatastoreUrlPair_Holder" - self.pyclass = Holder - - class VirtualMachineConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineConfigInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"modified"), aname="_modified", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivNodeWorldWideName"), aname="_npivNodeWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivPortWorldWideName"), aname="_npivPortWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"npivWorldWideNameType"), aname="_npivWorldWideNameType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredNodeWwns"), aname="_npivDesiredNodeWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredPortWwns"), aname="_npivDesiredPortWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivTemporaryDisabled"), aname="_npivTemporaryDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivOnNonRdmDisks"), aname="_npivOnNonRdmDisks", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locationId"), aname="_locationId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"alternateGuestName"), aname="_alternateGuestName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileInfo",lazy=True)(pname=(ns,"files"), aname="_files", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ToolsConfigInfo",lazy=True)(pname=(ns,"tools"), aname="_tools", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFlagInfo",lazy=True)(pname=(ns,"flags"), aname="_flags", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConsolePreferences",lazy=True)(pname=(ns,"consolePreferences"), aname="_consolePreferences", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDefaultPowerOpInfo",lazy=True)(pname=(ns,"defaultPowerOps"), aname="_defaultPowerOps", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualHardware",lazy=True)(pname=(ns,"hardware"), aname="_hardware", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"cpuAllocation"), aname="_cpuAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"memoryAllocation"), aname="_memoryAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memoryHotAddEnabled"), aname="_memoryHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotAddEnabled"), aname="_cpuHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotRemoveEnabled"), aname="_cpuHotRemoveEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hotPlugMemoryLimit"), aname="_hotPlugMemoryLimit", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"hotPlugMemoryIncrementSize"), aname="_hotPlugMemoryIncrementSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"cpuAffinity"), aname="_cpuAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"memoryAffinity"), aname="_memoryAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineNetworkShaperInfo",lazy=True)(pname=(ns,"networkShaper"), aname="_networkShaper", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"extraConfig"), aname="_extraConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeatureMask"), aname="_cpuFeatureMask", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigInfoDatastoreUrlPair",lazy=True)(pname=(ns,"datastoreUrl"), aname="_datastoreUrl", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"swapPlacement"), aname="_swapPlacement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineBootOptions",lazy=True)(pname=(ns,"bootOptions"), aname="_bootOptions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FaultToleranceConfigInfo",lazy=True)(pname=(ns,"ftInfo"), aname="_ftInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmConfigInfo",lazy=True)(pname=(ns,"vAppConfig"), aname="_vAppConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vAssertsEnabled"), aname="_vAssertsEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"changeTrackingEnabled"), aname="_changeTrackingEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineConfigInfo_Def.__bases__: - bases = list(ns0.VirtualMachineConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineConfigOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineConfigOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestOsDescriptor",lazy=True)(pname=(ns,"guestOSDescriptor"), aname="_guestOSDescriptor", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"guestOSDefaultIndex"), aname="_guestOSDefaultIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualHardwareOption",lazy=True)(pname=(ns,"hardwareOptions"), aname="_hardwareOptions", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCapability",lazy=True)(pname=(ns,"capabilities"), aname="_capabilities", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreOption",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"defaultDevice"), aname="_defaultDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedMonitorType"), aname="_supportedMonitorType", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedOvfEnvironmentTransport"), aname="_supportedOvfEnvironmentTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedOvfInstallTransport"), aname="_supportedOvfInstallTransport", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineConfigOption_Def.__bases__: - bases = list(ns0.VirtualMachineConfigOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineConfigOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineConfigOptionDescriptor_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigOptionDescriptor") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineConfigOptionDescriptor_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"createSupported"), aname="_createSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"defaultConfigOption"), aname="_defaultConfigOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineConfigOptionDescriptor_Def.__bases__: - bases = list(ns0.VirtualMachineConfigOptionDescriptor_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineConfigOptionDescriptor_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineConfigOptionDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineConfigOptionDescriptor") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineConfigOptionDescriptor_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineConfigOptionDescriptor",lazy=True)(pname=(ns,"VirtualMachineConfigOptionDescriptor"), aname="_VirtualMachineConfigOptionDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineConfigOptionDescriptor = [] - return - Holder.__name__ = "ArrayOfVirtualMachineConfigOptionDescriptor_Holder" - self.pyclass = Holder - - class VirtualMachineConfigSpecNpivWwnOp_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigSpecNpivWwnOp") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineCpuIdInfoSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineCpuIdInfoSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineCpuIdInfoSpec_Def.schema - TClist = [GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"info"), aname="_info", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ArrayUpdateSpec_Def not in ns0.VirtualMachineCpuIdInfoSpec_Def.__bases__: - bases = list(ns0.VirtualMachineCpuIdInfoSpec_Def.__bases__) - bases.insert(0, ns0.ArrayUpdateSpec_Def) - ns0.VirtualMachineCpuIdInfoSpec_Def.__bases__ = tuple(bases) - - ns0.ArrayUpdateSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineCpuIdInfoSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineCpuIdInfoSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineCpuIdInfoSpec_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineCpuIdInfoSpec",lazy=True)(pname=(ns,"VirtualMachineCpuIdInfoSpec"), aname="_VirtualMachineCpuIdInfoSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineCpuIdInfoSpec = [] - return - Holder.__name__ = "ArrayOfVirtualMachineCpuIdInfoSpec_Holder" - self.pyclass = Holder - - class VirtualMachineConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineConfigSpec_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"changeVersion"), aname="_changeVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"version"), aname="_version", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivNodeWorldWideName"), aname="_npivNodeWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"npivPortWorldWideName"), aname="_npivPortWorldWideName", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"npivWorldWideNameType"), aname="_npivWorldWideNameType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredNodeWwns"), aname="_npivDesiredNodeWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"npivDesiredPortWwns"), aname="_npivDesiredPortWwns", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivTemporaryDisabled"), aname="_npivTemporaryDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"npivOnNonRdmDisks"), aname="_npivOnNonRdmDisks", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"npivWorldWideNameOp"), aname="_npivWorldWideNameOp", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"locationId"), aname="_locationId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"alternateGuestName"), aname="_alternateGuestName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileInfo",lazy=True)(pname=(ns,"files"), aname="_files", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ToolsConfigInfo",lazy=True)(pname=(ns,"tools"), aname="_tools", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFlagInfo",lazy=True)(pname=(ns,"flags"), aname="_flags", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConsolePreferences",lazy=True)(pname=(ns,"consolePreferences"), aname="_consolePreferences", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDefaultPowerOpInfo",lazy=True)(pname=(ns,"powerOpInfo"), aname="_powerOpInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCPUs"), aname="_numCPUs", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"memoryHotAddEnabled"), aname="_memoryHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotAddEnabled"), aname="_cpuHotAddEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cpuHotRemoveEnabled"), aname="_cpuHotRemoveEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConfigSpec",lazy=True)(pname=(ns,"deviceChange"), aname="_deviceChange", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"cpuAllocation"), aname="_cpuAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourceAllocationInfo",lazy=True)(pname=(ns,"memoryAllocation"), aname="_memoryAllocation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"cpuAffinity"), aname="_cpuAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineAffinityInfo",lazy=True)(pname=(ns,"memoryAffinity"), aname="_memoryAffinity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineNetworkShaperInfo",lazy=True)(pname=(ns,"networkShaper"), aname="_networkShaper", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCpuIdInfoSpec",lazy=True)(pname=(ns,"cpuFeatureMask"), aname="_cpuFeatureMask", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"extraConfig"), aname="_extraConfig", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"swapPlacement"), aname="_swapPlacement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineBootOptions",lazy=True)(pname=(ns,"bootOptions"), aname="_bootOptions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VmConfigSpec",lazy=True)(pname=(ns,"vAppConfig"), aname="_vAppConfig", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FaultToleranceConfigInfo",lazy=True)(pname=(ns,"ftInfo"), aname="_ftInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vAppConfigRemoved"), aname="_vAppConfigRemoved", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"vAssertsEnabled"), aname="_vAssertsEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"changeTrackingEnabled"), aname="_changeTrackingEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineConfigSpec_Def.__bases__: - bases = list(ns0.VirtualMachineConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ConfigTarget_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ConfigTarget") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ConfigTarget_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numCpus"), aname="_numCpus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpuCores"), aname="_numCpuCores", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numNumaNodes"), aname="_numNumaNodes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineDatastoreInfo",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineNetworkInfo",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualPortgroupInfo",lazy=True)(pname=(ns,"distributedVirtualPortgroup"), aname="_distributedVirtualPortgroup", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DistributedVirtualSwitchInfo",lazy=True)(pname=(ns,"distributedVirtualSwitch"), aname="_distributedVirtualSwitch", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineCdromInfo",lazy=True)(pname=(ns,"cdRom"), aname="_cdRom", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSerialInfo",lazy=True)(pname=(ns,"serial"), aname="_serial", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineParallelInfo",lazy=True)(pname=(ns,"parallel"), aname="_parallel", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSoundInfo",lazy=True)(pname=(ns,"sound"), aname="_sound", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineUsbInfo",lazy=True)(pname=(ns,"usb"), aname="_usb", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFloppyInfo",lazy=True)(pname=(ns,"floppy"), aname="_floppy", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineLegacyNetworkSwitchInfo",lazy=True)(pname=(ns,"legacyNetworkInfo"), aname="_legacyNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineScsiPassthroughInfo",lazy=True)(pname=(ns,"scsiPassthrough"), aname="_scsiPassthrough", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineScsiDiskDeviceInfo",lazy=True)(pname=(ns,"scsiDisk"), aname="_scsiDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineIdeDiskDeviceInfo",lazy=True)(pname=(ns,"ideDisk"), aname="_ideDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemMBOptimalPerf"), aname="_maxMemMBOptimalPerf", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ResourcePoolRuntimeInfo",lazy=True)(pname=(ns,"resourcePool"), aname="_resourcePool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoVmotion"), aname="_autoVmotion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePciPassthroughInfo",lazy=True)(pname=(ns,"pciPassthrough"), aname="_pciPassthrough", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ConfigTarget_Def.__bases__: - bases = list(ns0.ConfigTarget_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ConfigTarget_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineConsolePreferences_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineConsolePreferences") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineConsolePreferences_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"powerOnWhenOpened"), aname="_powerOnWhenOpened", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enterFullScreenOnPowerOn"), aname="_enterFullScreenOnPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"closeOnPowerOffOrSuspend"), aname="_closeOnPowerOffOrSuspend", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineConsolePreferences_Def.__bases__: - bases = list(ns0.VirtualMachineConsolePreferences_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineConsolePreferences_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineDatastoreInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineDatastoreInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineDatastoreInfo_Def.schema - TClist = [GTD("urn:vim25","DatastoreSummary",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","DatastoreCapability",lazy=True)(pname=(ns,"capability"), aname="_capability", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"maxFileSize"), aname="_maxFileSize", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"mode"), aname="_mode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineDatastoreInfo_Def.__bases__: - bases = list(ns0.VirtualMachineDatastoreInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineDatastoreInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineDatastoreInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineDatastoreInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineDatastoreInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineDatastoreInfo",lazy=True)(pname=(ns,"VirtualMachineDatastoreInfo"), aname="_VirtualMachineDatastoreInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineDatastoreInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineDatastoreInfo_Holder" - self.pyclass = Holder - - class VirtualMachineDatastoreVolumeOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineDatastoreVolumeOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineDatastoreVolumeOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"fileSystemType"), aname="_fileSystemType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"majorVersion"), aname="_majorVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineDatastoreVolumeOption_Def.__bases__: - bases = list(ns0.VirtualMachineDatastoreVolumeOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineDatastoreVolumeOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineDatastoreVolumeOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineDatastoreVolumeOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineDatastoreVolumeOption_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineDatastoreVolumeOption",lazy=True)(pname=(ns,"VirtualMachineDatastoreVolumeOption"), aname="_VirtualMachineDatastoreVolumeOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineDatastoreVolumeOption = [] - return - Holder.__name__ = "ArrayOfVirtualMachineDatastoreVolumeOption_Holder" - self.pyclass = Holder - - class DatastoreOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "DatastoreOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.DatastoreOption_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineDatastoreVolumeOption",lazy=True)(pname=(ns,"unsupportedVolumes"), aname="_unsupportedVolumes", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.DatastoreOption_Def.__bases__: - bases = list(ns0.DatastoreOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.DatastoreOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachinePowerOpType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachinePowerOpType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineStandbyActionType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineStandbyActionType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineDefaultPowerOpInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineDefaultPowerOpInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineDefaultPowerOpInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"powerOffType"), aname="_powerOffType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"suspendType"), aname="_suspendType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"resetType"), aname="_resetType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultPowerOffType"), aname="_defaultPowerOffType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultSuspendType"), aname="_defaultSuspendType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"defaultResetType"), aname="_defaultResetType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"standbyAction"), aname="_standbyAction", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineDefaultPowerOpInfo_Def.__bases__: - bases = list(ns0.VirtualMachineDefaultPowerOpInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineDefaultPowerOpInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineDiskDeviceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineDiskDeviceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineDiskDeviceInfo_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineDiskDeviceInfo_Def.__bases__: - bases = list(ns0.VirtualMachineDiskDeviceInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineDiskDeviceInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultToleranceConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultToleranceConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultToleranceConfigInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"role"), aname="_role", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuids"), aname="_instanceUuids", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configPaths"), aname="_configPaths", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.FaultToleranceConfigInfo_Def.__bases__: - bases = list(ns0.FaultToleranceConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.FaultToleranceConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultTolerancePrimaryConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultTolerancePrimaryConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultTolerancePrimaryConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"secondaries"), aname="_secondaries", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FaultToleranceConfigInfo_Def not in ns0.FaultTolerancePrimaryConfigInfo_Def.__bases__: - bases = list(ns0.FaultTolerancePrimaryConfigInfo_Def.__bases__) - bases.insert(0, ns0.FaultToleranceConfigInfo_Def) - ns0.FaultTolerancePrimaryConfigInfo_Def.__bases__ = tuple(bases) - - ns0.FaultToleranceConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultToleranceSecondaryConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultToleranceSecondaryConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultToleranceSecondaryConfigInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"primaryVM"), aname="_primaryVM", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.FaultToleranceConfigInfo_Def not in ns0.FaultToleranceSecondaryConfigInfo_Def.__bases__: - bases = list(ns0.FaultToleranceSecondaryConfigInfo_Def.__bases__) - bases.insert(0, ns0.FaultToleranceConfigInfo_Def) - ns0.FaultToleranceSecondaryConfigInfo_Def.__bases__ = tuple(bases) - - ns0.FaultToleranceConfigInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class FaultToleranceSecondaryOpResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "FaultToleranceSecondaryOpResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.FaultToleranceSecondaryOpResult_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"powerOnAttempted"), aname="_powerOnAttempted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ClusterPowerOnVmResult",lazy=True)(pname=(ns,"powerOnResult"), aname="_powerOnResult", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.FaultToleranceSecondaryOpResult_Def.__bases__: - bases = list(ns0.FaultToleranceSecondaryOpResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.FaultToleranceSecondaryOpResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"vmPathName"), aname="_vmPathName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"snapshotDirectory"), aname="_snapshotDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"suspendDirectory"), aname="_suspendDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"logDirectory"), aname="_logDirectory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileInfo_Def.__bases__: - bases = list(ns0.VirtualMachineFileInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineFileLayoutDiskLayout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutDiskLayout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayoutDiskLayout_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskFile"), aname="_diskFile", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutDiskLayout_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayoutDiskLayout_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayoutDiskLayout_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineFileLayoutDiskLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineFileLayoutDiskLayout") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineFileLayoutDiskLayout_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFileLayoutDiskLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutDiskLayout"), aname="_VirtualMachineFileLayoutDiskLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineFileLayoutDiskLayout = [] - return - Holder.__name__ = "ArrayOfVirtualMachineFileLayoutDiskLayout_Holder" - self.pyclass = Holder - - class VirtualMachineFileLayoutSnapshotLayout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutSnapshotLayout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayoutSnapshotLayout_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"snapshotFile"), aname="_snapshotFile", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutSnapshotLayout_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayoutSnapshotLayout_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayoutSnapshotLayout_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineFileLayoutSnapshotLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineFileLayoutSnapshotLayout") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineFileLayoutSnapshotLayout_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFileLayoutSnapshotLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutSnapshotLayout"), aname="_VirtualMachineFileLayoutSnapshotLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineFileLayoutSnapshotLayout = [] - return - Holder.__name__ = "ArrayOfVirtualMachineFileLayoutSnapshotLayout_Holder" - self.pyclass = Holder - - class VirtualMachineFileLayout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayout_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"configFile"), aname="_configFile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"logFile"), aname="_logFile", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutDiskLayout",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutSnapshotLayout",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"swapFile"), aname="_swapFile", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayout_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayout_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayout_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineFileLayoutExFileType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutExFileType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineFileLayoutExFileInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutExFileInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayoutExFileInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"size"), aname="_size", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExFileInfo_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayoutExFileInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayoutExFileInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineFileLayoutExFileInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineFileLayoutExFileInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineFileLayoutExFileInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExFileInfo",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExFileInfo"), aname="_VirtualMachineFileLayoutExFileInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineFileLayoutExFileInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExFileInfo_Holder" - self.pyclass = Holder - - class VirtualMachineFileLayoutExDiskUnit_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutExDiskUnit") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayoutExDiskUnit_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"fileKey"), aname="_fileKey", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExDiskUnit_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayoutExDiskUnit_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayoutExDiskUnit_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineFileLayoutExDiskUnit_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineFileLayoutExDiskUnit") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineFileLayoutExDiskUnit_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExDiskUnit",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExDiskUnit"), aname="_VirtualMachineFileLayoutExDiskUnit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineFileLayoutExDiskUnit = [] - return - Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExDiskUnit_Holder" - self.pyclass = Holder - - class VirtualMachineFileLayoutExDiskLayout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutExDiskLayout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayoutExDiskLayout_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExDiskUnit",lazy=True)(pname=(ns,"chain"), aname="_chain", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExDiskLayout_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayoutExDiskLayout_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayoutExDiskLayout_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineFileLayoutExDiskLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineFileLayoutExDiskLayout") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineFileLayoutExDiskLayout_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExDiskLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExDiskLayout"), aname="_VirtualMachineFileLayoutExDiskLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineFileLayoutExDiskLayout = [] - return - Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExDiskLayout_Holder" - self.pyclass = Holder - - class VirtualMachineFileLayoutExSnapshotLayout_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutExSnapshotLayout") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"dataKey"), aname="_dataKey", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExDiskLayout",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayoutExSnapshotLayout_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineFileLayoutExSnapshotLayout_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineFileLayoutExSnapshotLayout") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineFileLayoutExSnapshotLayout_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExSnapshotLayout",lazy=True)(pname=(ns,"VirtualMachineFileLayoutExSnapshotLayout"), aname="_VirtualMachineFileLayoutExSnapshotLayout", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineFileLayoutExSnapshotLayout = [] - return - Holder.__name__ = "ArrayOfVirtualMachineFileLayoutExSnapshotLayout_Holder" - self.pyclass = Holder - - class VirtualMachineFileLayoutEx_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFileLayoutEx") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFileLayoutEx_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFileLayoutExFileInfo",lazy=True)(pname=(ns,"file"), aname="_file", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExDiskLayout",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFileLayoutExSnapshotLayout",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFileLayoutEx_Def.__bases__: - bases = list(ns0.VirtualMachineFileLayoutEx_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFileLayoutEx_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineHtSharing_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineHtSharing") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachinePowerOffBehavior_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachinePowerOffBehavior") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineFlagInfoMonitorType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineFlagInfoMonitorType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineFlagInfoVirtualMmuUsage_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineFlagInfoVirtualMmuUsage") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineFlagInfoVirtualExecUsage_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineFlagInfoVirtualExecUsage") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineFlagInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFlagInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFlagInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"disableAcceleration"), aname="_disableAcceleration", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enableLogging"), aname="_enableLogging", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useToe"), aname="_useToe", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"runWithDebugInfo"), aname="_runWithDebugInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"monitorType"), aname="_monitorType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"htSharing"), aname="_htSharing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"snapshotDisabled"), aname="_snapshotDisabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"snapshotLocked"), aname="_snapshotLocked", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"diskUuidEnabled"), aname="_diskUuidEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"virtualMmuUsage"), aname="_virtualMmuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"virtualExecUsage"), aname="_virtualExecUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"snapshotPowerOffBehavior"), aname="_snapshotPowerOffBehavior", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"recordReplayEnabled"), aname="_recordReplayEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineFlagInfo_Def.__bases__: - bases = list(ns0.VirtualMachineFlagInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineFlagInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineFloppyInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineFloppyInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineFloppyInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineFloppyInfo_Def.__bases__: - bases = list(ns0.VirtualMachineFloppyInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineFloppyInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineFloppyInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineFloppyInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineFloppyInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineFloppyInfo",lazy=True)(pname=(ns,"VirtualMachineFloppyInfo"), aname="_VirtualMachineFloppyInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineFloppyInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineFloppyInfo_Holder" - self.pyclass = Holder - - class VirtualMachineToolsStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineToolsStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineToolsVersionStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineToolsVersionStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineToolsRunningStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineToolsRunningStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class GuestDiskInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GuestDiskInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GuestDiskInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskPath"), aname="_diskPath", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacity"), aname="_capacity", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"freeSpace"), aname="_freeSpace", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.GuestDiskInfo_Def.__bases__: - bases = list(ns0.GuestDiskInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.GuestDiskInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfGuestDiskInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfGuestDiskInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfGuestDiskInfo_Def.schema - TClist = [GTD("urn:vim25","GuestDiskInfo",lazy=True)(pname=(ns,"GuestDiskInfo"), aname="_GuestDiskInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._GuestDiskInfo = [] - return - Holder.__name__ = "ArrayOfGuestDiskInfo_Holder" - self.pyclass = Holder - - class GuestNicInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GuestNicInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GuestNicInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"deviceConfigId"), aname="_deviceConfigId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.GuestNicInfo_Def.__bases__: - bases = list(ns0.GuestNicInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.GuestNicInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfGuestNicInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfGuestNicInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfGuestNicInfo_Def.schema - TClist = [GTD("urn:vim25","GuestNicInfo",lazy=True)(pname=(ns,"GuestNicInfo"), aname="_GuestNicInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._GuestNicInfo = [] - return - Holder.__name__ = "ArrayOfGuestNicInfo_Holder" - self.pyclass = Holder - - class GuestScreenInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GuestScreenInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GuestScreenInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.GuestScreenInfo_Def.__bases__: - bases = list(ns0.GuestScreenInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.GuestScreenInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineGuestState_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineGuestState") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class GuestInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GuestInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GuestInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineToolsStatus",lazy=True)(pname=(ns,"toolsStatus"), aname="_toolsStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsVersionStatus"), aname="_toolsVersionStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsRunningStatus"), aname="_toolsRunningStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsVersion"), aname="_toolsVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFamily"), aname="_guestFamily", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestNicInfo",lazy=True)(pname=(ns,"net"), aname="_net", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestDiskInfo",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","GuestScreenInfo",lazy=True)(pname=(ns,"screen"), aname="_screen", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestState"), aname="_guestState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.GuestInfo_Def.__bases__: - bases = list(ns0.GuestInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.GuestInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineGuestOsFamily_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineGuestOsFamily") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineGuestOsIdentifier_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineGuestOsIdentifier") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class GuestOsDescriptor_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "GuestOsDescriptor") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.GuestOsDescriptor_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"family"), aname="_family", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedMaxCPUs"), aname="_supportedMaxCPUs", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedMinMemMB"), aname="_supportedMinMemMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedMaxMemMB"), aname="_supportedMaxMemMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"recommendedMemMB"), aname="_recommendedMemMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"recommendedColorDepth"), aname="_recommendedColorDepth", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedDiskControllerList"), aname="_supportedDiskControllerList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"recommendedSCSIController"), aname="_recommendedSCSIController", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"recommendedDiskController"), aname="_recommendedDiskController", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"supportedNumDisks"), aname="_supportedNumDisks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"recommendedDiskSizeMB"), aname="_recommendedDiskSizeMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedEthernetCard"), aname="_supportedEthernetCard", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"recommendedEthernetCard"), aname="_recommendedEthernetCard", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsSlaveDisk"), aname="_supportsSlaveDisk", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","HostCpuIdInfo",lazy=True)(pname=(ns,"cpuFeatureMask"), aname="_cpuFeatureMask", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsWakeOnLan"), aname="_supportsWakeOnLan", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsVMI"), aname="_supportsVMI", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsMemoryHotAdd"), aname="_supportsMemoryHotAdd", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsCpuHotAdd"), aname="_supportsCpuHotAdd", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"supportsCpuHotRemove"), aname="_supportsCpuHotRemove", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.GuestOsDescriptor_Def.__bases__: - bases = list(ns0.GuestOsDescriptor_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.GuestOsDescriptor_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfGuestOsDescriptor_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfGuestOsDescriptor") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfGuestOsDescriptor_Def.schema - TClist = [GTD("urn:vim25","GuestOsDescriptor",lazy=True)(pname=(ns,"GuestOsDescriptor"), aname="_GuestOsDescriptor", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._GuestOsDescriptor = [] - return - Holder.__name__ = "ArrayOfGuestOsDescriptor_Holder" - self.pyclass = Holder - - class VirtualMachineIdeDiskDevicePartitionInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineIdeDiskDevicePartitionInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"capacity"), aname="_capacity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.__bases__: - bases = list(ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineIdeDiskDevicePartitionInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineIdeDiskDevicePartitionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineIdeDiskDevicePartitionInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineIdeDiskDevicePartitionInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineIdeDiskDevicePartitionInfo",lazy=True)(pname=(ns,"VirtualMachineIdeDiskDevicePartitionInfo"), aname="_VirtualMachineIdeDiskDevicePartitionInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineIdeDiskDevicePartitionInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineIdeDiskDevicePartitionInfo_Holder" - self.pyclass = Holder - - class VirtualMachineIdeDiskDeviceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineIdeDiskDeviceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineIdeDiskDeviceInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineIdeDiskDevicePartitionInfo",lazy=True)(pname=(ns,"partitionTable"), aname="_partitionTable", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineDiskDeviceInfo_Def not in ns0.VirtualMachineIdeDiskDeviceInfo_Def.__bases__: - bases = list(ns0.VirtualMachineIdeDiskDeviceInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineDiskDeviceInfo_Def) - ns0.VirtualMachineIdeDiskDeviceInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineDiskDeviceInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineIdeDiskDeviceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineIdeDiskDeviceInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineIdeDiskDeviceInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineIdeDiskDeviceInfo",lazy=True)(pname=(ns,"VirtualMachineIdeDiskDeviceInfo"), aname="_VirtualMachineIdeDiskDeviceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineIdeDiskDeviceInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineIdeDiskDeviceInfo_Holder" - self.pyclass = Holder - - class VirtualMachineLegacyNetworkSwitchInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineLegacyNetworkSwitchInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.__bases__: - bases = list(ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineLegacyNetworkSwitchInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineLegacyNetworkSwitchInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineLegacyNetworkSwitchInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineLegacyNetworkSwitchInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineLegacyNetworkSwitchInfo",lazy=True)(pname=(ns,"VirtualMachineLegacyNetworkSwitchInfo"), aname="_VirtualMachineLegacyNetworkSwitchInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineLegacyNetworkSwitchInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineLegacyNetworkSwitchInfo_Holder" - self.pyclass = Holder - - class VirtualMachineMessage_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineMessage") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineMessage_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"text"), aname="_text", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineMessage_Def.__bases__: - bases = list(ns0.VirtualMachineMessage_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineMessage_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineMessage_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineMessage") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineMessage_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"VirtualMachineMessage"), aname="_VirtualMachineMessage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineMessage = [] - return - Holder.__name__ = "ArrayOfVirtualMachineMessage_Holder" - self.pyclass = Holder - - class VirtualMachineNetworkInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineNetworkInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineNetworkInfo_Def.schema - TClist = [GTD("urn:vim25","NetworkSummary",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineNetworkInfo_Def.__bases__: - bases = list(ns0.VirtualMachineNetworkInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineNetworkInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineNetworkInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineNetworkInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineNetworkInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineNetworkInfo",lazy=True)(pname=(ns,"VirtualMachineNetworkInfo"), aname="_VirtualMachineNetworkInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineNetworkInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineNetworkInfo_Holder" - self.pyclass = Holder - - class VirtualMachineNetworkShaperInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineNetworkShaperInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineNetworkShaperInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"enabled"), aname="_enabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"peakBps"), aname="_peakBps", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"averageBps"), aname="_averageBps", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"burstSize"), aname="_burstSize", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineNetworkShaperInfo_Def.__bases__: - bases = list(ns0.VirtualMachineNetworkShaperInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineNetworkShaperInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineParallelInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineParallelInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineParallelInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineParallelInfo_Def.__bases__: - bases = list(ns0.VirtualMachineParallelInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineParallelInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineParallelInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineParallelInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineParallelInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineParallelInfo",lazy=True)(pname=(ns,"VirtualMachineParallelInfo"), aname="_VirtualMachineParallelInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineParallelInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineParallelInfo_Holder" - self.pyclass = Holder - - class VirtualMachinePciPassthroughInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachinePciPassthroughInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachinePciPassthroughInfo_Def.schema - TClist = [GTD("urn:vim25","HostPciDevice",lazy=True)(pname=(ns,"pciDevice"), aname="_pciDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemId"), aname="_systemId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachinePciPassthroughInfo_Def.__bases__: - bases = list(ns0.VirtualMachinePciPassthroughInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachinePciPassthroughInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachinePciPassthroughInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachinePciPassthroughInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachinePciPassthroughInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachinePciPassthroughInfo",lazy=True)(pname=(ns,"VirtualMachinePciPassthroughInfo"), aname="_VirtualMachinePciPassthroughInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachinePciPassthroughInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachinePciPassthroughInfo_Holder" - self.pyclass = Holder - - class VirtualMachineQuestionInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineQuestionInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineQuestionInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"text"), aname="_text", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"choice"), aname="_choice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineMessage",lazy=True)(pname=(ns,"message"), aname="_message", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineQuestionInfo_Def.__bases__: - bases = list(ns0.VirtualMachineQuestionInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineQuestionInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineRelocateTransformation_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineRelocateTransformation") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineRelocateSpecDiskLocator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineRelocateSpecDiskLocator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineRelocateSpecDiskLocator_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"diskId"), aname="_diskId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskMoveType"), aname="_diskMoveType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineRelocateSpecDiskLocator_Def.__bases__: - bases = list(ns0.VirtualMachineRelocateSpecDiskLocator_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineRelocateSpecDiskLocator_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineRelocateSpecDiskLocator_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineRelocateSpecDiskLocator") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineRelocateSpecDiskLocator_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineRelocateSpecDiskLocator",lazy=True)(pname=(ns,"VirtualMachineRelocateSpecDiskLocator"), aname="_VirtualMachineRelocateSpecDiskLocator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineRelocateSpecDiskLocator = [] - return - Holder.__name__ = "ArrayOfVirtualMachineRelocateSpecDiskLocator_Holder" - self.pyclass = Holder - - class VirtualMachineRelocateDiskMoveOptions_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineRelocateDiskMoveOptions") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineRelocateSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineRelocateSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineRelocateSpec_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskMoveType"), aname="_diskMoveType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateSpecDiskLocator",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateTransformation",lazy=True)(pname=(ns,"transform"), aname="_transform", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineRelocateSpec_Def.__bases__: - bases = list(ns0.VirtualMachineRelocateSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineRelocateSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineRuntimeInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineRuntimeInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineRuntimeInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConnectionState",lazy=True)(pname=(ns,"connectionState"), aname="_connectionState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"powerState"), aname="_powerState", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineFaultToleranceState",lazy=True)(pname=(ns,"faultToleranceState"), aname="_faultToleranceState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"toolsInstallerMounted"), aname="_toolsInstallerMounted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"suspendTime"), aname="_suspendTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"bootTime"), aname="_bootTime", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"suspendInterval"), aname="_suspendInterval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineQuestionInfo",lazy=True)(pname=(ns,"question"), aname="_question", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"memoryOverhead"), aname="_memoryOverhead", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxCpuUsage"), aname="_maxCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"maxMemoryUsage"), aname="_maxMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numMksConnections"), aname="_numMksConnections", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRecordReplayState",lazy=True)(pname=(ns,"recordReplayState"), aname="_recordReplayState", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"cleanPowerOff"), aname="_cleanPowerOff", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"needSecondaryReason"), aname="_needSecondaryReason", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineRuntimeInfo_Def.__bases__: - bases = list(ns0.VirtualMachineRuntimeInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineRuntimeInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineScsiDiskDeviceInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineScsiDiskDeviceInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineScsiDiskDeviceInfo_Def.schema - TClist = [GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"disk"), aname="_disk", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"transportHint"), aname="_transportHint", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"lunNumber"), aname="_lunNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineDiskDeviceInfo_Def not in ns0.VirtualMachineScsiDiskDeviceInfo_Def.__bases__: - bases = list(ns0.VirtualMachineScsiDiskDeviceInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineDiskDeviceInfo_Def) - ns0.VirtualMachineScsiDiskDeviceInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineDiskDeviceInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineScsiDiskDeviceInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineScsiDiskDeviceInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineScsiDiskDeviceInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineScsiDiskDeviceInfo",lazy=True)(pname=(ns,"VirtualMachineScsiDiskDeviceInfo"), aname="_VirtualMachineScsiDiskDeviceInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineScsiDiskDeviceInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineScsiDiskDeviceInfo_Holder" - self.pyclass = Holder - - class VirtualMachineScsiPassthroughType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineScsiPassthroughType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineScsiPassthroughInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineScsiPassthroughInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineScsiPassthroughInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"scsiClass"), aname="_scsiClass", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"physicalUnitNumber"), aname="_physicalUnitNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineScsiPassthroughInfo_Def.__bases__: - bases = list(ns0.VirtualMachineScsiPassthroughInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineScsiPassthroughInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineScsiPassthroughInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineScsiPassthroughInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineScsiPassthroughInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineScsiPassthroughInfo",lazy=True)(pname=(ns,"VirtualMachineScsiPassthroughInfo"), aname="_VirtualMachineScsiPassthroughInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineScsiPassthroughInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineScsiPassthroughInfo_Holder" - self.pyclass = Holder - - class VirtualMachineSerialInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineSerialInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineSerialInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineSerialInfo_Def.__bases__: - bases = list(ns0.VirtualMachineSerialInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineSerialInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineSerialInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineSerialInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineSerialInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineSerialInfo",lazy=True)(pname=(ns,"VirtualMachineSerialInfo"), aname="_VirtualMachineSerialInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineSerialInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineSerialInfo_Holder" - self.pyclass = Holder - - class RevertToSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RevertToSnapshotRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RevertToSnapshotRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"suppressPowerOn"), aname="_suppressPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._host = None - self._suppressPowerOn = None - return - Holder.__name__ = "RevertToSnapshotRequestType_Holder" - self.pyclass = Holder - - class RemoveSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RemoveSnapshotRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RemoveSnapshotRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"removeChildren"), aname="_removeChildren", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._removeChildren = None - return - Holder.__name__ = "RemoveSnapshotRequestType_Holder" - self.pyclass = Holder - - class RenameSnapshotRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "RenameSnapshotRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.RenameSnapshotRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._name = None - self._description = None - return - Holder.__name__ = "RenameSnapshotRequestType_Holder" - self.pyclass = Holder - - class VirtualMachineSnapshotInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineSnapshotInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineSnapshotInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"currentSnapshot"), aname="_currentSnapshot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSnapshotTree",lazy=True)(pname=(ns,"rootSnapshotList"), aname="_rootSnapshotList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineSnapshotInfo_Def.__bases__: - bases = list(ns0.VirtualMachineSnapshotInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineSnapshotInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineSnapshotTree_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineSnapshotTree") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineSnapshotTree_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"snapshot"), aname="_snapshot", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"createTime"), aname="_createTime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"quiesced"), aname="_quiesced", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"backupManifest"), aname="_backupManifest", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSnapshotTree",lazy=True)(pname=(ns,"childSnapshotList"), aname="_childSnapshotList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"replaySupported"), aname="_replaySupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineSnapshotTree_Def.__bases__: - bases = list(ns0.VirtualMachineSnapshotTree_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineSnapshotTree_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineSnapshotTree_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineSnapshotTree") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineSnapshotTree_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineSnapshotTree",lazy=True)(pname=(ns,"VirtualMachineSnapshotTree"), aname="_VirtualMachineSnapshotTree", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineSnapshotTree = [] - return - Holder.__name__ = "ArrayOfVirtualMachineSnapshotTree_Holder" - self.pyclass = Holder - - class VirtualMachineSoundInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineSoundInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineSoundInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineSoundInfo_Def.__bases__: - bases = list(ns0.VirtualMachineSoundInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineSoundInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineSoundInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineSoundInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineSoundInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineSoundInfo",lazy=True)(pname=(ns,"VirtualMachineSoundInfo"), aname="_VirtualMachineSoundInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineSoundInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineSoundInfo_Holder" - self.pyclass = Holder - - class VirtualMachineUsageOnDatastore_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineUsageOnDatastore") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineUsageOnDatastore_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"committed"), aname="_committed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"uncommitted"), aname="_uncommitted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unshared"), aname="_unshared", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineUsageOnDatastore_Def.__bases__: - bases = list(ns0.VirtualMachineUsageOnDatastore_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineUsageOnDatastore_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineUsageOnDatastore_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineUsageOnDatastore") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineUsageOnDatastore_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineUsageOnDatastore",lazy=True)(pname=(ns,"VirtualMachineUsageOnDatastore"), aname="_VirtualMachineUsageOnDatastore", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineUsageOnDatastore = [] - return - Holder.__name__ = "ArrayOfVirtualMachineUsageOnDatastore_Holder" - self.pyclass = Holder - - class VirtualMachineStorageInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineStorageInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineStorageInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineUsageOnDatastore",lazy=True)(pname=(ns,"perDatastoreUsage"), aname="_perDatastoreUsage", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineStorageInfo_Def.__bases__: - bases = list(ns0.VirtualMachineStorageInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineStorageInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineConfigSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineConfigSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineConfigSummary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"template"), aname="_template", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"vmPathName"), aname="_vmPathName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memorySizeMB"), aname="_memorySizeMB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"cpuReservation"), aname="_cpuReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryReservation"), aname="_memoryReservation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCpu"), aname="_numCpu", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numEthernetCards"), aname="_numEthernetCards", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numVirtualDisks"), aname="_numVirtualDisks", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"instanceUuid"), aname="_instanceUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"annotation"), aname="_annotation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VAppProductInfo",lazy=True)(pname=(ns,"product"), aname="_product", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"installBootRequired"), aname="_installBootRequired", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","FaultToleranceConfigInfo",lazy=True)(pname=(ns,"ftInfo"), aname="_ftInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineConfigSummary_Def.__bases__: - bases = list(ns0.VirtualMachineConfigSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineConfigSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineQuickStats_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineQuickStats") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineQuickStats_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"overallCpuUsage"), aname="_overallCpuUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"overallCpuDemand"), aname="_overallCpuDemand", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"guestMemoryUsage"), aname="_guestMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"hostMemoryUsage"), aname="_hostMemoryUsage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"guestHeartbeatStatus"), aname="_guestHeartbeatStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedCpuEntitlement"), aname="_distributedCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"distributedMemoryEntitlement"), aname="_distributedMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticCpuEntitlement"), aname="_staticCpuEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"staticMemoryEntitlement"), aname="_staticMemoryEntitlement", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"privateMemory"), aname="_privateMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"sharedMemory"), aname="_sharedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"swappedMemory"), aname="_swappedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"balloonedMemory"), aname="_balloonedMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"consumedOverheadMemory"), aname="_consumedOverheadMemory", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ftLogBandwidth"), aname="_ftLogBandwidth", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ftSecondaryLatency"), aname="_ftSecondaryLatency", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"ftLatencyStatus"), aname="_ftLatencyStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineQuickStats_Def.__bases__: - bases = list(ns0.VirtualMachineQuickStats_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineQuickStats_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineGuestSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineGuestSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineGuestSummary_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"guestId"), aname="_guestId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"guestFullName"), aname="_guestFullName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineToolsStatus",lazy=True)(pname=(ns,"toolsStatus"), aname="_toolsStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsVersionStatus"), aname="_toolsVersionStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsRunningStatus"), aname="_toolsRunningStatus", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"hostName"), aname="_hostName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineGuestSummary_Def.__bases__: - bases = list(ns0.VirtualMachineGuestSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineGuestSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineStorageSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineStorageSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineStorageSummary_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"committed"), aname="_committed", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"uncommitted"), aname="_uncommitted", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"unshared"), aname="_unshared", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCtimes.gDateTime(pname=(ns,"timestamp"), aname="_timestamp", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineStorageSummary_Def.__bases__: - bases = list(ns0.VirtualMachineStorageSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineStorageSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineSummary_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineSummary") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineSummary_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRuntimeInfo",lazy=True)(pname=(ns,"runtime"), aname="_runtime", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineGuestSummary",lazy=True)(pname=(ns,"guest"), aname="_guest", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineConfigSummary",lazy=True)(pname=(ns,"config"), aname="_config", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineStorageSummary",lazy=True)(pname=(ns,"storage"), aname="_storage", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineQuickStats",lazy=True)(pname=(ns,"quickStats"), aname="_quickStats", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedEntityStatus",lazy=True)(pname=(ns,"overallStatus"), aname="_overallStatus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomFieldValue",lazy=True)(pname=(ns,"customValue"), aname="_customValue", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineSummary_Def.__bases__: - bases = list(ns0.VirtualMachineSummary_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineSummary_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineSummary_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineSummary") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineSummary_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineSummary",lazy=True)(pname=(ns,"VirtualMachineSummary"), aname="_VirtualMachineSummary", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineSummary = [] - return - Holder.__name__ = "ArrayOfVirtualMachineSummary_Holder" - self.pyclass = Holder - - class VirtualMachineTargetInfoConfigurationTag_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineTargetInfoConfigurationTag") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineTargetInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineTargetInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineTargetInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"configurationTag"), aname="_configurationTag", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualMachineTargetInfo_Def.__bases__: - bases = list(ns0.VirtualMachineTargetInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualMachineTargetInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class UpgradePolicy_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "UpgradePolicy") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ToolsConfigInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ToolsConfigInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ToolsConfigInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"toolsVersion"), aname="_toolsVersion", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"afterPowerOn"), aname="_afterPowerOn", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"afterResume"), aname="_afterResume", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"beforeGuestStandby"), aname="_beforeGuestStandby", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"beforeGuestShutdown"), aname="_beforeGuestShutdown", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"beforeGuestReboot"), aname="_beforeGuestReboot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"toolsUpgradePolicy"), aname="_toolsUpgradePolicy", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"pendingCustomization"), aname="_pendingCustomization", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"syncTimeWithHost"), aname="_syncTimeWithHost", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.ToolsConfigInfo_Def.__bases__: - bases = list(ns0.ToolsConfigInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.ToolsConfigInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineUsbInfoSpeed_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineUsbInfoSpeed") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineUsbInfoFamily_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualMachineUsbInfoFamily") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualMachineUsbInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineUsbInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineUsbInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"description"), aname="_description", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"vendor"), aname="_vendor", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"product"), aname="_product", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"physicalPath"), aname="_physicalPath", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"family"), aname="_family", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"speed"), aname="_speed", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineSummary",lazy=True)(pname=(ns,"summary"), aname="_summary", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualMachineTargetInfo_Def not in ns0.VirtualMachineUsbInfo_Def.__bases__: - bases = list(ns0.VirtualMachineUsbInfo_Def.__bases__) - bases.insert(0, ns0.VirtualMachineTargetInfo_Def) - ns0.VirtualMachineUsbInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualMachineTargetInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualMachineUsbInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualMachineUsbInfo") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualMachineUsbInfo_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineUsbInfo",lazy=True)(pname=(ns,"VirtualMachineUsbInfo"), aname="_VirtualMachineUsbInfo", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualMachineUsbInfo = [] - return - Holder.__name__ = "ArrayOfVirtualMachineUsbInfo_Holder" - self.pyclass = Holder - - class VirtualHardware_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualHardware") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualHardware_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"numCPU"), aname="_numCPU", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualHardware_Def.__bases__: - bases = list(ns0.VirtualHardware_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualHardware_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualHardwareOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualHardwareOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualHardwareOption_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"hwVersion"), aname="_hwVersion", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceOption",lazy=True)(pname=(ns,"virtualDeviceOption"), aname="_virtualDeviceOption", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deviceListReadonly"), aname="_deviceListReadonly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numCPU"), aname="_numCPU", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"numCpuReadonly"), aname="_numCpuReadonly", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LongOption",lazy=True)(pname=(ns,"memoryMB"), aname="_memoryMB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPCIControllers"), aname="_numPCIControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numIDEControllers"), aname="_numIDEControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numUSBControllers"), aname="_numUSBControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSIOControllers"), aname="_numSIOControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPS2Controllers"), aname="_numPS2Controllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licensingLimit"), aname="_licensingLimit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSupportedWwnPorts"), aname="_numSupportedWwnPorts", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSupportedWwnNodes"), aname="_numSupportedWwnNodes", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualHardwareOption_Def.__bases__: - bases = list(ns0.VirtualHardwareOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualHardwareOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineImportSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineImportSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineImportSpec_Def.schema - TClist = [GTD("urn:vim25","VirtualMachineConfigSpec",lazy=True)(pname=(ns,"configSpec"), aname="_configSpec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.ImportSpec_Def not in ns0.VirtualMachineImportSpec_Def.__bases__: - bases = list(ns0.VirtualMachineImportSpec_Def.__bases__) - bases.insert(0, ns0.ImportSpec_Def) - ns0.VirtualMachineImportSpec_Def.__bases__ = tuple(bases) - - ns0.ImportSpec_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CheckCompatibilityRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckCompatibilityRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckCompatibilityRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - self._host = None - self._pool = None - self._testType = [] - return - Holder.__name__ = "CheckCompatibilityRequestType_Holder" - self.pyclass = Holder - - class QueryVMotionCompatibilityExRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "QueryVMotionCompatibilityExRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.QueryVMotionCompatibilityExRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = [] - self._host = [] - return - Holder.__name__ = "QueryVMotionCompatibilityExRequestType_Holder" - self.pyclass = Holder - - class CheckMigrateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckMigrateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckMigrateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"pool"), aname="_pool", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachinePowerState",lazy=True)(pname=(ns,"state"), aname="_state", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - self._host = None - self._pool = None - self._state = None - self._testType = [] - return - Holder.__name__ = "CheckMigrateRequestType_Holder" - self.pyclass = Holder - - class CheckRelocateRequestType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckRelocateRequestType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.CheckRelocateRequestType_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"_this"), aname="__this", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualMachineRelocateSpec",lazy=True)(pname=(ns,"spec"), aname="_spec", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"testType"), aname="_testType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self.__this = None - self._vm = None - self._spec = None - self._testType = [] - return - Holder.__name__ = "CheckRelocateRequestType_Holder" - self.pyclass = Holder - - class CheckResult_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CheckResult") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CheckResult_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"vm"), aname="_vm", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"host"), aname="_host", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"warning"), aname="_warning", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","LocalizedMethodFault",lazy=True)(pname=(ns,"error"), aname="_error", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CheckResult_Def.__bases__: - bases = list(ns0.CheckResult_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CheckResult_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfCheckResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfCheckResult") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfCheckResult_Def.schema - TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"CheckResult"), aname="_CheckResult", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._CheckResult = [] - return - Holder.__name__ = "ArrayOfCheckResult_Holder" - self.pyclass = Holder - - class CheckTestType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CheckTestType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class CustomizationSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationSpec_Def.schema - TClist = [GTD("urn:vim25","CustomizationOptions",lazy=True)(pname=(ns,"options"), aname="_options", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIdentitySettings",lazy=True)(pname=(ns,"identity"), aname="_identity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationGlobalIPSettings",lazy=True)(pname=(ns,"globalIPSettings"), aname="_globalIPSettings", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationAdapterMapping",lazy=True)(pname=(ns,"nicSettingMap"), aname="_nicSettingMap", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ibyte(pname=(ns,"encryptionKey"), aname="_encryptionKey", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationSpec_Def.__bases__: - bases = list(ns0.CustomizationSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationName_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationName_Def.__bases__: - bases = list(ns0.CustomizationName_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationName_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationFixedName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationFixedName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationFixedName_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationName_Def not in ns0.CustomizationFixedName_Def.__bases__: - bases = list(ns0.CustomizationFixedName_Def.__bases__) - bases.insert(0, ns0.CustomizationName_Def) - ns0.CustomizationFixedName_Def.__bases__ = tuple(bases) - - ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationPrefixName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationPrefixName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationPrefixName_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"base"), aname="_base", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationName_Def not in ns0.CustomizationPrefixName_Def.__bases__: - bases = list(ns0.CustomizationPrefixName_Def.__bases__) - bases.insert(0, ns0.CustomizationName_Def) - ns0.CustomizationPrefixName_Def.__bases__ = tuple(bases) - - ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationVirtualMachineName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationVirtualMachineName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationVirtualMachineName_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationName_Def not in ns0.CustomizationVirtualMachineName_Def.__bases__: - bases = list(ns0.CustomizationVirtualMachineName_Def.__bases__) - bases.insert(0, ns0.CustomizationName_Def) - ns0.CustomizationVirtualMachineName_Def.__bases__ = tuple(bases) - - ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationUnknownName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationUnknownName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationUnknownName_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationName_Def not in ns0.CustomizationUnknownName_Def.__bases__: - bases = list(ns0.CustomizationUnknownName_Def.__bases__) - bases.insert(0, ns0.CustomizationName_Def) - ns0.CustomizationUnknownName_Def.__bases__ = tuple(bases) - - ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationCustomName_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationCustomName") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationCustomName_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationName_Def not in ns0.CustomizationCustomName_Def.__bases__: - bases = list(ns0.CustomizationCustomName_Def.__bases__) - bases.insert(0, ns0.CustomizationName_Def) - ns0.CustomizationCustomName_Def.__bases__ = tuple(bases) - - ns0.CustomizationName_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationPassword_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationPassword") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationPassword_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"plainText"), aname="_plainText", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationPassword_Def.__bases__: - bases = list(ns0.CustomizationPassword_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationPassword_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationOptions_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationOptions") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationOptions_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationOptions_Def.__bases__: - bases = list(ns0.CustomizationOptions_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationOptions_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationSysprepRebootOption_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CustomizationSysprepRebootOption") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class CustomizationWinOptions_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationWinOptions") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationWinOptions_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"changeSID"), aname="_changeSID", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deleteAccounts"), aname="_deleteAccounts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationSysprepRebootOption",lazy=True)(pname=(ns,"reboot"), aname="_reboot", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationOptions_Def not in ns0.CustomizationWinOptions_Def.__bases__: - bases = list(ns0.CustomizationWinOptions_Def.__bases__) - bases.insert(0, ns0.CustomizationOptions_Def) - ns0.CustomizationWinOptions_Def.__bases__ = tuple(bases) - - ns0.CustomizationOptions_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationLinuxOptions_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationLinuxOptions") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationLinuxOptions_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationOptions_Def not in ns0.CustomizationLinuxOptions_Def.__bases__: - bases = list(ns0.CustomizationLinuxOptions_Def.__bases__) - bases.insert(0, ns0.CustomizationOptions_Def) - ns0.CustomizationLinuxOptions_Def.__bases__ = tuple(bases) - - ns0.CustomizationOptions_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationGuiUnattended_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationGuiUnattended") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationGuiUnattended_Def.schema - TClist = [GTD("urn:vim25","CustomizationPassword",lazy=True)(pname=(ns,"password"), aname="_password", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"autoLogon"), aname="_autoLogon", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"autoLogonCount"), aname="_autoLogonCount", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationGuiUnattended_Def.__bases__: - bases = list(ns0.CustomizationGuiUnattended_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationGuiUnattended_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationUserData_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationUserData") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationUserData_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"fullName"), aname="_fullName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"orgName"), aname="_orgName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationName",lazy=True)(pname=(ns,"computerName"), aname="_computerName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"productId"), aname="_productId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationUserData_Def.__bases__: - bases = list(ns0.CustomizationUserData_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationUserData_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationGuiRunOnce_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationGuiRunOnce") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationGuiRunOnce_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"commandList"), aname="_commandList", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationGuiRunOnce_Def.__bases__: - bases = list(ns0.CustomizationGuiRunOnce_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationGuiRunOnce_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationIdentification_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationIdentification") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationIdentification_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"joinWorkgroup"), aname="_joinWorkgroup", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"joinDomain"), aname="_joinDomain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domainAdmin"), aname="_domainAdmin", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationPassword",lazy=True)(pname=(ns,"domainAdminPassword"), aname="_domainAdminPassword", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationIdentification_Def.__bases__: - bases = list(ns0.CustomizationIdentification_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationIdentification_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationLicenseDataMode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CustomizationLicenseDataMode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class CustomizationLicenseFilePrintData_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationLicenseFilePrintData") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationLicenseFilePrintData_Def.schema - TClist = [GTD("urn:vim25","CustomizationLicenseDataMode",lazy=True)(pname=(ns,"autoMode"), aname="_autoMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"autoUsers"), aname="_autoUsers", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationLicenseFilePrintData_Def.__bases__: - bases = list(ns0.CustomizationLicenseFilePrintData_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationLicenseFilePrintData_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationIdentitySettings_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationIdentitySettings") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationIdentitySettings_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationIdentitySettings_Def.__bases__: - bases = list(ns0.CustomizationIdentitySettings_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationIdentitySettings_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationSysprepText_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationSysprepText") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationSysprepText_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"value"), aname="_value", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIdentitySettings_Def not in ns0.CustomizationSysprepText_Def.__bases__: - bases = list(ns0.CustomizationSysprepText_Def.__bases__) - bases.insert(0, ns0.CustomizationIdentitySettings_Def) - ns0.CustomizationSysprepText_Def.__bases__ = tuple(bases) - - ns0.CustomizationIdentitySettings_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationSysprep_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationSysprep") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationSysprep_Def.schema - TClist = [GTD("urn:vim25","CustomizationGuiUnattended",lazy=True)(pname=(ns,"guiUnattended"), aname="_guiUnattended", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationUserData",lazy=True)(pname=(ns,"userData"), aname="_userData", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationGuiRunOnce",lazy=True)(pname=(ns,"guiRunOnce"), aname="_guiRunOnce", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIdentification",lazy=True)(pname=(ns,"identification"), aname="_identification", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationLicenseFilePrintData",lazy=True)(pname=(ns,"licenseFilePrintData"), aname="_licenseFilePrintData", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIdentitySettings_Def not in ns0.CustomizationSysprep_Def.__bases__: - bases = list(ns0.CustomizationSysprep_Def.__bases__) - bases.insert(0, ns0.CustomizationIdentitySettings_Def) - ns0.CustomizationSysprep_Def.__bases__ = tuple(bases) - - ns0.CustomizationIdentitySettings_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationLinuxPrep_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationLinuxPrep") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationLinuxPrep_Def.schema - TClist = [GTD("urn:vim25","CustomizationName",lazy=True)(pname=(ns,"hostName"), aname="_hostName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"domain"), aname="_domain", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"timeZone"), aname="_timeZone", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hwClockUTC"), aname="_hwClockUTC", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIdentitySettings_Def not in ns0.CustomizationLinuxPrep_Def.__bases__: - bases = list(ns0.CustomizationLinuxPrep_Def.__bases__) - bases.insert(0, ns0.CustomizationIdentitySettings_Def) - ns0.CustomizationLinuxPrep_Def.__bases__ = tuple(bases) - - ns0.CustomizationIdentitySettings_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationGlobalIPSettings_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationGlobalIPSettings") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationGlobalIPSettings_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"dnsSuffixList"), aname="_dnsSuffixList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsServerList"), aname="_dnsServerList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationGlobalIPSettings_Def.__bases__: - bases = list(ns0.CustomizationGlobalIPSettings_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationGlobalIPSettings_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationIPSettingsIpV6AddressSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationIPSettingsIpV6AddressSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationIPSettingsIpV6AddressSpec_Def.schema - TClist = [GTD("urn:vim25","CustomizationIpV6Generator",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationIPSettingsIpV6AddressSpec_Def.__bases__: - bases = list(ns0.CustomizationIPSettingsIpV6AddressSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationIPSettingsIpV6AddressSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationNetBIOSMode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "CustomizationNetBIOSMode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class CustomizationIPSettings_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationIPSettings") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationIPSettings_Def.schema - TClist = [GTD("urn:vim25","CustomizationIpGenerator",lazy=True)(pname=(ns,"ip"), aname="_ip", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"gateway"), aname="_gateway", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIPSettingsIpV6AddressSpec",lazy=True)(pname=(ns,"ipV6Spec"), aname="_ipV6Spec", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsServerList"), aname="_dnsServerList", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dnsDomain"), aname="_dnsDomain", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"primaryWINS"), aname="_primaryWINS", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"secondaryWINS"), aname="_secondaryWINS", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationNetBIOSMode",lazy=True)(pname=(ns,"netBIOS"), aname="_netBIOS", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationIPSettings_Def.__bases__: - bases = list(ns0.CustomizationIPSettings_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationIPSettings_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationIpGenerator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationIpGenerator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationIpGenerator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationIpGenerator_Def.__bases__: - bases = list(ns0.CustomizationIpGenerator_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationIpGenerator_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationDhcpIpGenerator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationDhcpIpGenerator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationDhcpIpGenerator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationDhcpIpGenerator_Def.__bases__: - bases = list(ns0.CustomizationDhcpIpGenerator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpGenerator_Def) - ns0.CustomizationDhcpIpGenerator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationFixedIp_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationFixedIp") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationFixedIp_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationFixedIp_Def.__bases__: - bases = list(ns0.CustomizationFixedIp_Def.__bases__) - bases.insert(0, ns0.CustomizationIpGenerator_Def) - ns0.CustomizationFixedIp_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationUnknownIpGenerator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationUnknownIpGenerator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationUnknownIpGenerator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationUnknownIpGenerator_Def.__bases__: - bases = list(ns0.CustomizationUnknownIpGenerator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpGenerator_Def) - ns0.CustomizationUnknownIpGenerator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationCustomIpGenerator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationCustomIpGenerator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationCustomIpGenerator_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpGenerator_Def not in ns0.CustomizationCustomIpGenerator_Def.__bases__: - bases = list(ns0.CustomizationCustomIpGenerator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpGenerator_Def) - ns0.CustomizationCustomIpGenerator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpGenerator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationIpV6Generator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationIpV6Generator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationIpV6Generator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationIpV6Generator_Def.__bases__: - bases = list(ns0.CustomizationIpV6Generator_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationIpV6Generator_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfCustomizationIpV6Generator_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfCustomizationIpV6Generator") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfCustomizationIpV6Generator_Def.schema - TClist = [GTD("urn:vim25","CustomizationIpV6Generator",lazy=True)(pname=(ns,"CustomizationIpV6Generator"), aname="_CustomizationIpV6Generator", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._CustomizationIpV6Generator = [] - return - Holder.__name__ = "ArrayOfCustomizationIpV6Generator_Holder" - self.pyclass = Holder - - class CustomizationDhcpIpV6Generator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationDhcpIpV6Generator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationDhcpIpV6Generator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationDhcpIpV6Generator_Def.__bases__: - bases = list(ns0.CustomizationDhcpIpV6Generator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpV6Generator_Def) - ns0.CustomizationDhcpIpV6Generator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationStatelessIpV6Generator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationStatelessIpV6Generator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationStatelessIpV6Generator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationStatelessIpV6Generator_Def.__bases__: - bases = list(ns0.CustomizationStatelessIpV6Generator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpV6Generator_Def) - ns0.CustomizationStatelessIpV6Generator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationFixedIpV6_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationFixedIpV6") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationFixedIpV6_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"ipAddress"), aname="_ipAddress", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"subnetMask"), aname="_subnetMask", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationFixedIpV6_Def.__bases__: - bases = list(ns0.CustomizationFixedIpV6_Def.__bases__) - bases.insert(0, ns0.CustomizationIpV6Generator_Def) - ns0.CustomizationFixedIpV6_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationAutoIpV6Generator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationAutoIpV6Generator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationAutoIpV6Generator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationAutoIpV6Generator_Def.__bases__: - bases = list(ns0.CustomizationAutoIpV6Generator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpV6Generator_Def) - ns0.CustomizationAutoIpV6Generator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationUnknownIpV6Generator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationUnknownIpV6Generator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationUnknownIpV6Generator_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationUnknownIpV6Generator_Def.__bases__: - bases = list(ns0.CustomizationUnknownIpV6Generator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpV6Generator_Def) - ns0.CustomizationUnknownIpV6Generator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationCustomIpV6Generator_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationCustomIpV6Generator") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationCustomIpV6Generator_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"argument"), aname="_argument", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.CustomizationIpV6Generator_Def not in ns0.CustomizationCustomIpV6Generator_Def.__bases__: - bases = list(ns0.CustomizationCustomIpV6Generator_Def.__bases__) - bases.insert(0, ns0.CustomizationIpV6Generator_Def) - ns0.CustomizationCustomIpV6Generator_Def.__bases__ = tuple(bases) - - ns0.CustomizationIpV6Generator_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class CustomizationAdapterMapping_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "CustomizationAdapterMapping") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.CustomizationAdapterMapping_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","CustomizationIPSettings",lazy=True)(pname=(ns,"adapter"), aname="_adapter", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.CustomizationAdapterMapping_Def.__bases__: - bases = list(ns0.CustomizationAdapterMapping_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.CustomizationAdapterMapping_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfCustomizationAdapterMapping_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfCustomizationAdapterMapping") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfCustomizationAdapterMapping_Def.schema - TClist = [GTD("urn:vim25","CustomizationAdapterMapping",lazy=True)(pname=(ns,"CustomizationAdapterMapping"), aname="_CustomizationAdapterMapping", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._CustomizationAdapterMapping = [] - return - Holder.__name__ = "ArrayOfCustomizationAdapterMapping_Holder" - self.pyclass = Holder - - class HostDiskMappingPartitionInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskMappingPartitionInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskMappingPartitionInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fileSystem"), aname="_fileSystem", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacityInKb"), aname="_capacityInKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskMappingPartitionInfo_Def.__bases__: - bases = list(ns0.HostDiskMappingPartitionInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskMappingPartitionInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiskMappingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskMappingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskMappingInfo_Def.schema - TClist = [GTD("urn:vim25","HostDiskMappingPartitionInfo",lazy=True)(pname=(ns,"physicalPartition"), aname="_physicalPartition", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskMappingInfo_Def.__bases__: - bases = list(ns0.HostDiskMappingInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskMappingInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class HostDiskMappingPartitionOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskMappingPartitionOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskMappingPartitionOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"fileSystem"), aname="_fileSystem", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"capacityInKb"), aname="_capacityInKb", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskMappingPartitionOption_Def.__bases__: - bases = list(ns0.HostDiskMappingPartitionOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskMappingPartitionOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfHostDiskMappingPartitionOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfHostDiskMappingPartitionOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfHostDiskMappingPartitionOption_Def.schema - TClist = [GTD("urn:vim25","HostDiskMappingPartitionOption",lazy=True)(pname=(ns,"HostDiskMappingPartitionOption"), aname="_HostDiskMappingPartitionOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._HostDiskMappingPartitionOption = [] - return - Holder.__name__ = "ArrayOfHostDiskMappingPartitionOption_Holder" - self.pyclass = Holder - - class HostDiskMappingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "HostDiskMappingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.HostDiskMappingOption_Def.schema - TClist = [GTD("urn:vim25","HostDiskMappingPartitionOption",lazy=True)(pname=(ns,"physicalPartition"), aname="_physicalPartition", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"name"), aname="_name", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.HostDiskMappingOption_Def.__bases__: - bases = list(ns0.HostDiskMappingOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.HostDiskMappingOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ParaVirtualSCSIController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ParaVirtualSCSIController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ParaVirtualSCSIController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIController_Def not in ns0.ParaVirtualSCSIController_Def.__bases__: - bases = list(ns0.ParaVirtualSCSIController_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIController_Def) - ns0.ParaVirtualSCSIController_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ParaVirtualSCSIControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "ParaVirtualSCSIControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.ParaVirtualSCSIControllerOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIControllerOption_Def not in ns0.ParaVirtualSCSIControllerOption_Def.__bases__: - bases = list(ns0.ParaVirtualSCSIControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIControllerOption_Def) - ns0.ParaVirtualSCSIControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualBusLogicController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualBusLogicController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualBusLogicController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIController_Def not in ns0.VirtualBusLogicController_Def.__bases__: - bases = list(ns0.VirtualBusLogicController_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIController_Def) - ns0.VirtualBusLogicController_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualBusLogicControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualBusLogicControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualBusLogicControllerOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIControllerOption_Def not in ns0.VirtualBusLogicControllerOption_Def.__bases__: - bases = list(ns0.VirtualBusLogicControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIControllerOption_Def) - ns0.VirtualBusLogicControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromIsoBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromIsoBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromIsoBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualCdromIsoBackingInfo_Def.__bases__: - bases = list(ns0.VirtualCdromIsoBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualCdromIsoBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromPassthroughBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromPassthroughBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromPassthroughBackingInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualCdromPassthroughBackingInfo_Def.__bases__: - bases = list(ns0.VirtualCdromPassthroughBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualCdromPassthroughBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromRemotePassthroughBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromRemotePassthroughBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromRemotePassthroughBackingInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceRemoteDeviceBackingInfo_Def not in ns0.VirtualCdromRemotePassthroughBackingInfo_Def.__bases__: - bases = list(ns0.VirtualCdromRemotePassthroughBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingInfo_Def) - ns0.VirtualCdromRemotePassthroughBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromAtapiBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromAtapiBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromAtapiBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualCdromAtapiBackingInfo_Def.__bases__: - bases = list(ns0.VirtualCdromAtapiBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualCdromAtapiBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromRemoteAtapiBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromRemoteAtapiBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromRemoteAtapiBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceRemoteDeviceBackingInfo_Def not in ns0.VirtualCdromRemoteAtapiBackingInfo_Def.__bases__: - bases = list(ns0.VirtualCdromRemoteAtapiBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingInfo_Def) - ns0.VirtualCdromRemoteAtapiBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdrom_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdrom") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdrom_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualCdrom_Def.__bases__: - bases = list(ns0.VirtualCdrom_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualCdrom_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromIsoBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromIsoBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromIsoBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualCdromIsoBackingOption_Def.__bases__: - bases = list(ns0.VirtualCdromIsoBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualCdromIsoBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromPassthroughBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromPassthroughBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromPassthroughBackingOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualCdromPassthroughBackingOption_Def.__bases__: - bases = list(ns0.VirtualCdromPassthroughBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualCdromPassthroughBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromRemotePassthroughBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromRemotePassthroughBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromRemotePassthroughBackingOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"exclusive"), aname="_exclusive", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceRemoteDeviceBackingOption_Def not in ns0.VirtualCdromRemotePassthroughBackingOption_Def.__bases__: - bases = list(ns0.VirtualCdromRemotePassthroughBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingOption_Def) - ns0.VirtualCdromRemotePassthroughBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromAtapiBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromAtapiBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromAtapiBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualCdromAtapiBackingOption_Def.__bases__: - bases = list(ns0.VirtualCdromAtapiBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualCdromAtapiBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromRemoteAtapiBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromRemoteAtapiBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromRemoteAtapiBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualCdromRemoteAtapiBackingOption_Def.__bases__: - bases = list(ns0.VirtualCdromRemoteAtapiBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualCdromRemoteAtapiBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualCdromOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualCdromOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualCdromOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualCdromOption_Def.__bases__: - bases = list(ns0.VirtualCdromOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualCdromOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualController_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"busNumber"), aname="_busNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"device"), aname="_device", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualController_Def.__bases__: - bases = list(ns0.VirtualController_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualController_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualControllerOption_Def.schema - TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"devices"), aname="_devices", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"supportedDevice"), aname="_supportedDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualControllerOption_Def.__bases__: - bases = list(ns0.VirtualControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceFileBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceFileBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceFileBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"fileName"), aname="_fileName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"datastore"), aname="_datastore", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDeviceFileBackingInfo_Def.__bases__: - bases = list(ns0.VirtualDeviceFileBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) - ns0.VirtualDeviceFileBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceDeviceBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDeviceDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualDeviceDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) - ns0.VirtualDeviceDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceRemoteDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceRemoteDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) - ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDevicePipeBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDevicePipeBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDevicePipeBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"pipeName"), aname="_pipeName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualDevicePipeBackingInfo_Def.__bases__: - bases = list(ns0.VirtualDevicePipeBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) - ns0.VirtualDevicePipeBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceConnectInfoStatus_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDeviceConnectInfoStatus") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDeviceConnectInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceConnectInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceConnectInfo_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"startConnected"), aname="_startConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"allowGuestControl"), aname="_allowGuestControl", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"status"), aname="_status", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDeviceConnectInfo_Def.__bases__: - bases = list(ns0.VirtualDeviceConnectInfo_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDeviceConnectInfo_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDevice_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"key"), aname="_key", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","Description",lazy=True)(pname=(ns,"deviceInfo"), aname="_deviceInfo", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceBackingInfo",lazy=True)(pname=(ns,"backing"), aname="_backing", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConnectInfo",lazy=True)(pname=(ns,"connectable"), aname="_connectable", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"controllerKey"), aname="_controllerKey", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"unitNumber"), aname="_unitNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDevice_Def.__bases__: - bases = list(ns0.VirtualDevice_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDevice_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualDevice_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualDevice") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualDevice_Def.schema - TClist = [GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"VirtualDevice"), aname="_VirtualDevice", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualDevice = [] - return - Holder.__name__ = "ArrayOfVirtualDevice_Holder" - self.pyclass = Holder - - class VirtualDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceBackingOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualDeviceBackingOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualDeviceBackingOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualDeviceBackingOption_Def.schema - TClist = [GTD("urn:vim25","VirtualDeviceBackingOption",lazy=True)(pname=(ns,"VirtualDeviceBackingOption"), aname="_VirtualDeviceBackingOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualDeviceBackingOption = [] - return - Holder.__name__ = "ArrayOfVirtualDeviceBackingOption_Holder" - self.pyclass = Holder - - class VirtualDeviceFileExtension_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDeviceFileExtension") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDeviceFileBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceFileBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceFileBackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"fileNameExtensions"), aname="_fileNameExtensions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDeviceFileBackingOption_Def.__bases__: - bases = list(ns0.VirtualDeviceFileBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingOption_Def) - ns0.VirtualDeviceFileBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceDeviceBackingOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoDetectAvailable"), aname="_autoDetectAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDeviceDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualDeviceDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingOption_Def) - ns0.VirtualDeviceDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceRemoteDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceRemoteDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceRemoteDeviceBackingOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoDetectAvailable"), aname="_autoDetectAvailable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingOption_Def) - ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDevicePipeBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDevicePipeBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDevicePipeBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualDevicePipeBackingOption_Def.__bases__: - bases = list(ns0.VirtualDevicePipeBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingOption_Def) - ns0.VirtualDevicePipeBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceConnectOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceConnectOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceConnectOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"startConnected"), aname="_startConnected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"allowGuestControl"), aname="_allowGuestControl", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDeviceConnectOption_Def.__bases__: - bases = list(ns0.VirtualDeviceConnectOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDeviceConnectOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDeviceOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceOption_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"type"), aname="_type", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConnectOption",lazy=True)(pname=(ns,"connectOption"), aname="_connectOption", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"controllerType"), aname="_controllerType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoAssignController"), aname="_autoAssignController", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceBackingOption",lazy=True)(pname=(ns,"backingOption"), aname="_backingOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultBackingOptionIndex"), aname="_defaultBackingOptionIndex", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"licensingLimit"), aname="_licensingLimit", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"deprecated"), aname="_deprecated", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"plugAndPlay"), aname="_plugAndPlay", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hotRemoveSupported"), aname="_hotRemoveSupported", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDeviceOption_Def.__bases__: - bases = list(ns0.VirtualDeviceOption_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDeviceOption_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualDeviceOption_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualDeviceOption") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualDeviceOption_Def.schema - TClist = [GTD("urn:vim25","VirtualDeviceOption",lazy=True)(pname=(ns,"VirtualDeviceOption"), aname="_VirtualDeviceOption", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualDeviceOption = [] - return - Holder.__name__ = "ArrayOfVirtualDeviceOption_Holder" - self.pyclass = Holder - - class VirtualDeviceConfigSpecOperation_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDeviceConfigSpecOperation") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDeviceConfigSpecFileOperation_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDeviceConfigSpecFileOperation") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDeviceConfigSpec_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDeviceConfigSpec") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDeviceConfigSpec_Def.schema - TClist = [GTD("urn:vim25","VirtualDeviceConfigSpecOperation",lazy=True)(pname=(ns,"operation"), aname="_operation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDeviceConfigSpecFileOperation",lazy=True)(pname=(ns,"fileOperation"), aname="_fileOperation", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDevice",lazy=True)(pname=(ns,"device"), aname="_device", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.DynamicData_Def not in ns0.VirtualDeviceConfigSpec_Def.__bases__: - bases = list(ns0.VirtualDeviceConfigSpec_Def.__bases__) - bases.insert(0, ns0.DynamicData_Def) - ns0.VirtualDeviceConfigSpec_Def.__bases__ = tuple(bases) - - ns0.DynamicData_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualDeviceConfigSpec_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualDeviceConfigSpec") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualDeviceConfigSpec_Def.schema - TClist = [GTD("urn:vim25","VirtualDeviceConfigSpec",lazy=True)(pname=(ns,"VirtualDeviceConfigSpec"), aname="_VirtualDeviceConfigSpec", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualDeviceConfigSpec = [] - return - Holder.__name__ = "ArrayOfVirtualDeviceConfigSpec_Holder" - self.pyclass = Holder - - class VirtualDiskSparseVer1BackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskSparseVer1BackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskSparseVer1BackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"spaceUsedInKB"), aname="_spaceUsedInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSparseVer1BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskSparseVer1BackingInfo_Def.__bases__: - bases = list(ns0.VirtualDiskSparseVer1BackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualDiskSparseVer1BackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskSparseVer2BackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskSparseVer2BackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskSparseVer2BackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"spaceUsedInKB"), aname="_spaceUsedInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskSparseVer2BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskSparseVer2BackingInfo_Def.__bases__: - bases = list(ns0.VirtualDiskSparseVer2BackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualDiskSparseVer2BackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskFlatVer1BackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskFlatVer1BackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskFlatVer1BackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskFlatVer1BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskFlatVer1BackingInfo_Def.__bases__: - bases = list(ns0.VirtualDiskFlatVer1BackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualDiskFlatVer1BackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskFlatVer2BackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskFlatVer2BackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskFlatVer2BackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"split"), aname="_split", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"thinProvisioned"), aname="_thinProvisioned", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"eagerlyScrub"), aname="_eagerlyScrub", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskFlatVer2BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskFlatVer2BackingInfo_Def.__bases__: - bases = list(ns0.VirtualDiskFlatVer2BackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualDiskFlatVer2BackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskRawDiskVer2BackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskRawDiskVer2BackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskRawDiskVer2BackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"descriptorFileName"), aname="_descriptorFileName", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__bases__: - bases = list(ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskPartitionedRawDiskVer2BackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskPartitionedRawDiskVer2BackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"partition"), aname="_partition", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDiskRawDiskVer2BackingInfo_Def not in ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.__bases__: - bases = list(ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDiskRawDiskVer2BackingInfo_Def) - ns0.VirtualDiskPartitionedRawDiskVer2BackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDiskRawDiskVer2BackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskRawDiskMappingVer1BackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskRawDiskMappingVer1BackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"lunUuid"), aname="_lunUuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceName"), aname="_deviceName", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"compatibilityMode"), aname="_compatibilityMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"uuid"), aname="_uuid", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"contentId"), aname="_contentId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"changeId"), aname="_changeId", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualDiskRawDiskMappingVer1BackingInfo",lazy=True)(pname=(ns,"parent"), aname="_parent", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.__bases__: - bases = list(ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualDiskRawDiskMappingVer1BackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDisk_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDisk") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDisk_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"capacityInKB"), aname="_capacityInKB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","SharesInfo",lazy=True)(pname=(ns,"shares"), aname="_shares", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualDisk_Def.__bases__: - bases = list(ns0.VirtualDisk_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualDisk_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ArrayOfVirtualDisk_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualDisk") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualDisk_Def.schema - TClist = [GTD("urn:vim25","VirtualDisk",lazy=True)(pname=(ns,"VirtualDisk"), aname="_VirtualDisk", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualDisk = [] - return - Holder.__name__ = "ArrayOfVirtualDisk_Holder" - self.pyclass = Holder - - class VirtualDiskMode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDiskMode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDiskCompatibilityMode_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualDiskCompatibilityMode") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualDiskSparseVer1BackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskSparseVer1BackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskSparseVer1BackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskModes"), aname="_diskModes", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskSparseVer1BackingOption_Def.__bases__: - bases = list(ns0.VirtualDiskSparseVer1BackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualDiskSparseVer1BackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskSparseVer2BackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskSparseVer2BackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskSparseVer2BackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hotGrowable"), aname="_hotGrowable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskSparseVer2BackingOption_Def.__bases__: - bases = list(ns0.VirtualDiskSparseVer2BackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualDiskSparseVer2BackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskFlatVer1BackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskFlatVer1BackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskFlatVer1BackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskFlatVer1BackingOption_Def.__bases__: - bases = list(ns0.VirtualDiskFlatVer1BackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualDiskFlatVer1BackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskFlatVer2BackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskFlatVer2BackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskFlatVer2BackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"split"), aname="_split", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"writeThrough"), aname="_writeThrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"growable"), aname="_growable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"hotGrowable"), aname="_hotGrowable", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"thinProvisioned"), aname="_thinProvisioned", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"eagerlyScrub"), aname="_eagerlyScrub", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualDiskFlatVer2BackingOption_Def.__bases__: - bases = list(ns0.VirtualDiskFlatVer2BackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualDiskFlatVer2BackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskRawDiskVer2BackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskRawDiskVer2BackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskRawDiskVer2BackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"descriptorFileNameExtensions"), aname="_descriptorFileNameExtensions", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualDiskRawDiskVer2BackingOption_Def.__bases__: - bases = list(ns0.VirtualDiskRawDiskVer2BackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualDiskRawDiskVer2BackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskPartitionedRawDiskVer2BackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskPartitionedRawDiskVer2BackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDiskRawDiskVer2BackingOption_Def not in ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.__bases__: - bases = list(ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDiskRawDiskVer2BackingOption_Def) - ns0.VirtualDiskPartitionedRawDiskVer2BackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDiskRawDiskVer2BackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskRawDiskMappingVer1BackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskRawDiskMappingVer1BackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"descriptorFileNameExtensions"), aname="_descriptorFileNameExtensions", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"compatibilityMode"), aname="_compatibilityMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"diskMode"), aname="_diskMode", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"uuid"), aname="_uuid", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.__bases__: - bases = list(ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualDiskRawDiskMappingVer1BackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualDiskOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualDiskOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualDiskOption_Def.schema - TClist = [GTD("urn:vim25","LongOption",lazy=True)(pname=(ns,"capacityInKB"), aname="_capacityInKB", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualDiskOption_Def.__bases__: - bases = list(ns0.VirtualDiskOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualDiskOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualE1000_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualE1000") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualE1000_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualEthernetCard_Def not in ns0.VirtualE1000_Def.__bases__: - bases = list(ns0.VirtualE1000_Def.__bases__) - bases.insert(0, ns0.VirtualEthernetCard_Def) - ns0.VirtualE1000_Def.__bases__ = tuple(bases) - - ns0.VirtualEthernetCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualE1000Option_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualE1000Option") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualE1000Option_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualEthernetCardOption_Def not in ns0.VirtualE1000Option_Def.__bases__: - bases = list(ns0.VirtualE1000Option_Def.__bases__) - bases.insert(0, ns0.VirtualEthernetCardOption_Def) - ns0.VirtualE1000Option_Def.__bases__ = tuple(bases) - - ns0.VirtualEthernetCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEnsoniq1371_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEnsoniq1371") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEnsoniq1371_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSoundCard_Def not in ns0.VirtualEnsoniq1371_Def.__bases__: - bases = list(ns0.VirtualEnsoniq1371_Def.__bases__) - bases.insert(0, ns0.VirtualSoundCard_Def) - ns0.VirtualEnsoniq1371_Def.__bases__ = tuple(bases) - - ns0.VirtualSoundCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEnsoniq1371Option_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEnsoniq1371Option") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEnsoniq1371Option_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSoundCardOption_Def not in ns0.VirtualEnsoniq1371Option_Def.__bases__: - bases = list(ns0.VirtualEnsoniq1371Option_Def.__bases__) - bases.insert(0, ns0.VirtualSoundCardOption_Def) - ns0.VirtualEnsoniq1371Option_Def.__bases__ = tuple(bases) - - ns0.VirtualSoundCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardNetworkBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardNetworkBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardNetworkBackingInfo_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"network"), aname="_network", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"inPassthroughMode"), aname="_inPassthroughMode", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualEthernetCardNetworkBackingInfo_Def.__bases__: - bases = list(ns0.VirtualEthernetCardNetworkBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualEthernetCardNetworkBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardLegacyNetworkBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardLegacyNetworkBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.__bases__: - bases = list(ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualEthernetCardLegacyNetworkBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardDistributedVirtualPortBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardDistributedVirtualPortBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchPortConnection",lazy=True)(pname=(ns,"port"), aname="_port", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingInfo_Def not in ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.__bases__: - bases = list(ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingInfo_Def) - ns0.VirtualEthernetCardDistributedVirtualPortBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCard_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCard") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCard_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"addressType"), aname="_addressType", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"macAddress"), aname="_macAddress", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"wakeOnLanEnabled"), aname="_wakeOnLanEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualEthernetCard_Def.__bases__: - bases = list(ns0.VirtualEthernetCard_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualEthernetCard_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardNetworkBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardNetworkBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardNetworkBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualEthernetCardNetworkBackingOption_Def.__bases__: - bases = list(ns0.VirtualEthernetCardNetworkBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualEthernetCardNetworkBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardLegacyNetworkDeviceName_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardLegacyNetworkDeviceName") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualEthernetCardLegacyNetworkBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardLegacyNetworkBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.__bases__: - bases = list(ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualEthernetCardLegacyNetworkBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardDVPortBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardDVPortBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardDVPortBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceBackingOption_Def not in ns0.VirtualEthernetCardDVPortBackingOption_Def.__bases__: - bases = list(ns0.VirtualEthernetCardDVPortBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceBackingOption_Def) - ns0.VirtualEthernetCardDVPortBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualEthernetCardMacType_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardMacType") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualEthernetCardOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualEthernetCardOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualEthernetCardOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"supportedOUI"), aname="_supportedOUI", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"macType"), aname="_macType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"wakeOnLanEnabled"), aname="_wakeOnLanEnabled", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualEthernetCardOption_Def.__bases__: - bases = list(ns0.VirtualEthernetCardOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualEthernetCardOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppyImageBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppyImageBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppyImageBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualFloppyImageBackingInfo_Def.__bases__: - bases = list(ns0.VirtualFloppyImageBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualFloppyImageBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppyDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppyDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppyDeviceBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualFloppyDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualFloppyDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualFloppyDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppyRemoteDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppyRemoteDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceRemoteDeviceBackingInfo_Def not in ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingInfo_Def) - ns0.VirtualFloppyRemoteDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceRemoteDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppy_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppy") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppy_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualFloppy_Def.__bases__: - bases = list(ns0.VirtualFloppy_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualFloppy_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppyImageBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppyImageBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppyImageBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualFloppyImageBackingOption_Def.__bases__: - bases = list(ns0.VirtualFloppyImageBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualFloppyImageBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppyDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppyDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppyDeviceBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualFloppyDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualFloppyDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualFloppyDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppyRemoteDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppyRemoteDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppyRemoteDeviceBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceRemoteDeviceBackingOption_Def not in ns0.VirtualFloppyRemoteDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualFloppyRemoteDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceRemoteDeviceBackingOption_Def) - ns0.VirtualFloppyRemoteDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceRemoteDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualFloppyOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualFloppyOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualFloppyOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualFloppyOption_Def.__bases__: - bases = list(ns0.VirtualFloppyOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualFloppyOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualIDEController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualIDEController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualIDEController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualController_Def not in ns0.VirtualIDEController_Def.__bases__: - bases = list(ns0.VirtualIDEController_Def.__bases__) - bases.insert(0, ns0.VirtualController_Def) - ns0.VirtualIDEController_Def.__bases__ = tuple(bases) - - ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualIDEControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualIDEControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualIDEControllerOption_Def.schema - TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numIDEDisks"), aname="_numIDEDisks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numIDECdroms"), aname="_numIDECdroms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualControllerOption_Def not in ns0.VirtualIDEControllerOption_Def.__bases__: - bases = list(ns0.VirtualIDEControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualControllerOption_Def) - ns0.VirtualIDEControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualKeyboard_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualKeyboard") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualKeyboard_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualKeyboard_Def.__bases__: - bases = list(ns0.VirtualKeyboard_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualKeyboard_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualKeyboardOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualKeyboardOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualKeyboardOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualKeyboardOption_Def.__bases__: - bases = list(ns0.VirtualKeyboardOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualKeyboardOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualLsiLogicController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualLsiLogicController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualLsiLogicController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIController_Def not in ns0.VirtualLsiLogicController_Def.__bases__: - bases = list(ns0.VirtualLsiLogicController_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIController_Def) - ns0.VirtualLsiLogicController_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualLsiLogicControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualLsiLogicControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualLsiLogicControllerOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIControllerOption_Def not in ns0.VirtualLsiLogicControllerOption_Def.__bases__: - bases = list(ns0.VirtualLsiLogicControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIControllerOption_Def) - ns0.VirtualLsiLogicControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualLsiLogicSASController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualLsiLogicSASController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualLsiLogicSASController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIController_Def not in ns0.VirtualLsiLogicSASController_Def.__bases__: - bases = list(ns0.VirtualLsiLogicSASController_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIController_Def) - ns0.VirtualLsiLogicSASController_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualLsiLogicSASControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualLsiLogicSASControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualLsiLogicSASControllerOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSCSIControllerOption_Def not in ns0.VirtualLsiLogicSASControllerOption_Def.__bases__: - bases = list(ns0.VirtualLsiLogicSASControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualSCSIControllerOption_Def) - ns0.VirtualLsiLogicSASControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualSCSIControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCIController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCIController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCIController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualController_Def not in ns0.VirtualPCIController_Def.__bases__: - bases = list(ns0.VirtualPCIController_Def.__bases__) - bases.insert(0, ns0.VirtualController_Def) - ns0.VirtualPCIController_Def.__bases__ = tuple(bases) - - ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCIControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCIControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCIControllerOption_Def.schema - TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSIControllers"), aname="_numSCSIControllers", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numEthernetCards"), aname="_numEthernetCards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVideoCards"), aname="_numVideoCards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSoundCards"), aname="_numSoundCards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVmiRoms"), aname="_numVmiRoms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVmciDevices"), aname="_numVmciDevices", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPCIPassthroughDevices"), aname="_numPCIPassthroughDevices", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSasSCSIControllers"), aname="_numSasSCSIControllers", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numVmxnet3EthernetCards"), aname="_numVmxnet3EthernetCards", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numParaVirtualSCSIControllers"), aname="_numParaVirtualSCSIControllers", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualControllerOption_Def not in ns0.VirtualPCIControllerOption_Def.__bases__: - bases = list(ns0.VirtualPCIControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualControllerOption_Def) - ns0.VirtualPCIControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCIPassthroughDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCIPassthroughDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"deviceId"), aname="_deviceId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"systemId"), aname="_systemId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ishort(pname=(ns,"vendorId"), aname="_vendorId", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualPCIPassthroughDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCIPassthrough_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCIPassthrough") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCIPassthrough_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualPCIPassthrough_Def.__bases__: - bases = list(ns0.VirtualPCIPassthrough_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualPCIPassthrough_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCIPassthroughDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCIPassthroughDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCIPassthroughDeviceBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualPCIPassthroughDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualPCIPassthroughDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualPCIPassthroughDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCIPassthroughOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCIPassthroughOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCIPassthroughOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualPCIPassthroughOption_Def.__bases__: - bases = list(ns0.VirtualPCIPassthroughOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualPCIPassthroughOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCNet32_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCNet32") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCNet32_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualEthernetCard_Def not in ns0.VirtualPCNet32_Def.__bases__: - bases = list(ns0.VirtualPCNet32_Def.__bases__) - bases.insert(0, ns0.VirtualEthernetCard_Def) - ns0.VirtualPCNet32_Def.__bases__ = tuple(bases) - - ns0.VirtualEthernetCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPCNet32Option_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPCNet32Option") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPCNet32Option_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"supportsMorphing"), aname="_supportsMorphing", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualEthernetCardOption_Def not in ns0.VirtualPCNet32Option_Def.__bases__: - bases = list(ns0.VirtualPCNet32Option_Def.__bases__) - bases.insert(0, ns0.VirtualEthernetCardOption_Def) - ns0.VirtualPCNet32Option_Def.__bases__ = tuple(bases) - - ns0.VirtualEthernetCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPS2Controller_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPS2Controller") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPS2Controller_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualController_Def not in ns0.VirtualPS2Controller_Def.__bases__: - bases = list(ns0.VirtualPS2Controller_Def.__bases__) - bases.insert(0, ns0.VirtualController_Def) - ns0.VirtualPS2Controller_Def.__bases__ = tuple(bases) - - ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPS2ControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPS2ControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPS2ControllerOption_Def.schema - TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numKeyboards"), aname="_numKeyboards", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numPointingDevices"), aname="_numPointingDevices", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualControllerOption_Def not in ns0.VirtualPS2ControllerOption_Def.__bases__: - bases = list(ns0.VirtualPS2ControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualControllerOption_Def) - ns0.VirtualPS2ControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualParallelPortFileBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualParallelPortFileBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualParallelPortFileBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualParallelPortFileBackingInfo_Def.__bases__: - bases = list(ns0.VirtualParallelPortFileBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualParallelPortFileBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualParallelPortDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualParallelPortDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualParallelPortDeviceBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualParallelPortDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualParallelPortDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualParallelPortDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualParallelPort_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualParallelPort") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualParallelPort_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualParallelPort_Def.__bases__: - bases = list(ns0.VirtualParallelPort_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualParallelPort_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualParallelPortFileBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualParallelPortFileBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualParallelPortFileBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualParallelPortFileBackingOption_Def.__bases__: - bases = list(ns0.VirtualParallelPortFileBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualParallelPortFileBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualParallelPortDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualParallelPortDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualParallelPortDeviceBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualParallelPortDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualParallelPortDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualParallelPortDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualParallelPortOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualParallelPortOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualParallelPortOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualParallelPortOption_Def.__bases__: - bases = list(ns0.VirtualParallelPortOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualParallelPortOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPointingDeviceDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPointingDeviceDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPointingDeviceDeviceBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"hostPointingDevice"), aname="_hostPointingDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualPointingDeviceDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualPointingDeviceDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualPointingDeviceDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPointingDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPointingDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPointingDevice_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualPointingDevice_Def.__bases__: - bases = list(ns0.VirtualPointingDevice_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualPointingDevice_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPointingDeviceHostChoice_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualPointingDeviceHostChoice") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualPointingDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPointingDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPointingDeviceBackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"hostPointingDevice"), aname="_hostPointingDevice", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualPointingDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualPointingDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualPointingDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualPointingDeviceOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualPointingDeviceOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualPointingDeviceOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualPointingDeviceOption_Def.__bases__: - bases = list(ns0.VirtualPointingDeviceOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualPointingDeviceOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSCSISharing_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualSCSISharing") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class ArrayOfVirtualSCSISharing_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfVirtualSCSISharing") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfVirtualSCSISharing_Def.schema - TClist = [GTD("urn:vim25","VirtualSCSISharing",lazy=True)(pname=(ns,"VirtualSCSISharing"), aname="_VirtualSCSISharing", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._VirtualSCSISharing = [] - return - Holder.__name__ = "ArrayOfVirtualSCSISharing_Holder" - self.pyclass = Holder - - class VirtualSCSIController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSCSIController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSCSIController_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"hotAddRemove"), aname="_hotAddRemove", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualSCSISharing",lazy=True)(pname=(ns,"sharedBus"), aname="_sharedBus", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"scsiCtlrUnitNumber"), aname="_scsiCtlrUnitNumber", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualController_Def not in ns0.VirtualSCSIController_Def.__bases__: - bases = list(ns0.VirtualSCSIController_Def.__bases__) - bases.insert(0, ns0.VirtualController_Def) - ns0.VirtualSCSIController_Def.__bases__ = tuple(bases) - - ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSCSIControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSCSIControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSCSIControllerOption_Def.schema - TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSIDisks"), aname="_numSCSIDisks", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSICdroms"), aname="_numSCSICdroms", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSCSIPassthrough"), aname="_numSCSIPassthrough", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","VirtualSCSISharing",lazy=True)(pname=(ns,"sharing"), aname="_sharing", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"defaultSharedIndex"), aname="_defaultSharedIndex", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"hotAddRemove"), aname="_hotAddRemove", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"scsiCtlrUnitNumber"), aname="_scsiCtlrUnitNumber", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualControllerOption_Def not in ns0.VirtualSCSIControllerOption_Def.__bases__: - bases = list(ns0.VirtualSCSIControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualControllerOption_Def) - ns0.VirtualSCSIControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSCSIPassthroughDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSCSIPassthroughDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualSCSIPassthroughDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSCSIPassthrough_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSCSIPassthrough") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSCSIPassthrough_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualSCSIPassthrough_Def.__bases__: - bases = list(ns0.VirtualSCSIPassthrough_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualSCSIPassthrough_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSCSIPassthroughDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSCSIPassthroughDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualSCSIPassthroughDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSCSIPassthroughOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSCSIPassthroughOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSCSIPassthroughOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualSCSIPassthroughOption_Def.__bases__: - bases = list(ns0.VirtualSCSIPassthroughOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualSCSIPassthroughOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSIOController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSIOController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSIOController_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualController_Def not in ns0.VirtualSIOController_Def.__bases__: - bases = list(ns0.VirtualSIOController_Def.__bases__) - bases.insert(0, ns0.VirtualController_Def) - ns0.VirtualSIOController_Def.__bases__ = tuple(bases) - - ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSIOControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSIOControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSIOControllerOption_Def.schema - TClist = [GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numFloppyDrives"), aname="_numFloppyDrives", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numSerialPorts"), aname="_numSerialPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numParallelPorts"), aname="_numParallelPorts", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualControllerOption_Def not in ns0.VirtualSIOControllerOption_Def.__bases__: - bases = list(ns0.VirtualSIOControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualControllerOption_Def) - ns0.VirtualSIOControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPortFileBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPortFileBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPortFileBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingInfo_Def not in ns0.VirtualSerialPortFileBackingInfo_Def.__bases__: - bases = list(ns0.VirtualSerialPortFileBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingInfo_Def) - ns0.VirtualSerialPortFileBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPortDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPortDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPortDeviceBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualSerialPortDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualSerialPortDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualSerialPortDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPortPipeBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPortPipeBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPortPipeBackingInfo_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"endpoint"), aname="_endpoint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"noRxLoss"), aname="_noRxLoss", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevicePipeBackingInfo_Def not in ns0.VirtualSerialPortPipeBackingInfo_Def.__bases__: - bases = list(ns0.VirtualSerialPortPipeBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDevicePipeBackingInfo_Def) - ns0.VirtualSerialPortPipeBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDevicePipeBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPort_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPort") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPort_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"yieldOnPoll"), aname="_yieldOnPoll", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualSerialPort_Def.__bases__: - bases = list(ns0.VirtualSerialPort_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualSerialPort_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPortEndPoint_Def(ZSI.TC.String, TypeDefinition): - schema = "urn:vim25" - type = (schema, "VirtualSerialPortEndPoint") - def __init__(self, pname, **kw): - ZSI.TC.String.__init__(self, pname, pyclass=None, **kw) - class Holder(str): - typecode = self - self.pyclass = Holder - - class VirtualSerialPortFileBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPortFileBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPortFileBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceFileBackingOption_Def not in ns0.VirtualSerialPortFileBackingOption_Def.__bases__: - bases = list(ns0.VirtualSerialPortFileBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceFileBackingOption_Def) - ns0.VirtualSerialPortFileBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceFileBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPortDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPortDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPortDeviceBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualSerialPortDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualSerialPortDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualSerialPortDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPortPipeBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPortPipeBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPortPipeBackingOption_Def.schema - TClist = [GTD("urn:vim25","ChoiceOption",lazy=True)(pname=(ns,"endpoint"), aname="_endpoint", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"noRxLoss"), aname="_noRxLoss", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevicePipeBackingOption_Def not in ns0.VirtualSerialPortPipeBackingOption_Def.__bases__: - bases = list(ns0.VirtualSerialPortPipeBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDevicePipeBackingOption_Def) - ns0.VirtualSerialPortPipeBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDevicePipeBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSerialPortOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSerialPortOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSerialPortOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"yieldOnPoll"), aname="_yieldOnPoll", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualSerialPortOption_Def.__bases__: - bases = list(ns0.VirtualSerialPortOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualSerialPortOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSoundBlaster16_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSoundBlaster16") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSoundBlaster16_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSoundCard_Def not in ns0.VirtualSoundBlaster16_Def.__bases__: - bases = list(ns0.VirtualSoundBlaster16_Def.__bases__) - bases.insert(0, ns0.VirtualSoundCard_Def) - ns0.VirtualSoundBlaster16_Def.__bases__ = tuple(bases) - - ns0.VirtualSoundCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSoundBlaster16Option_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSoundBlaster16Option") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSoundBlaster16Option_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualSoundCardOption_Def not in ns0.VirtualSoundBlaster16Option_Def.__bases__: - bases = list(ns0.VirtualSoundBlaster16Option_Def.__bases__) - bases.insert(0, ns0.VirtualSoundCardOption_Def) - ns0.VirtualSoundBlaster16Option_Def.__bases__ = tuple(bases) - - ns0.VirtualSoundCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSoundCardDeviceBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSoundCardDeviceBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSoundCardDeviceBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualSoundCardDeviceBackingInfo_Def.__bases__: - bases = list(ns0.VirtualSoundCardDeviceBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualSoundCardDeviceBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSoundCard_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSoundCard") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSoundCard_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualSoundCard_Def.__bases__: - bases = list(ns0.VirtualSoundCard_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualSoundCard_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSoundCardDeviceBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSoundCardDeviceBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSoundCardDeviceBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualSoundCardDeviceBackingOption_Def.__bases__: - bases = list(ns0.VirtualSoundCardDeviceBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualSoundCardDeviceBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualSoundCardOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualSoundCardOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualSoundCardOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualSoundCardOption_Def.__bases__: - bases = list(ns0.VirtualSoundCardOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualSoundCardOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualUSBUSBBackingInfo_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualUSBUSBBackingInfo") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualUSBUSBBackingInfo_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingInfo_Def not in ns0.VirtualUSBUSBBackingInfo_Def.__bases__: - bases = list(ns0.VirtualUSBUSBBackingInfo_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingInfo_Def) - ns0.VirtualUSBUSBBackingInfo_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingInfo_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualUSB_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualUSB") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualUSB_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"connected"), aname="_connected", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualUSB_Def.__bases__: - bases = list(ns0.VirtualUSB_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualUSB_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualUSBController_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualUSBController") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualUSBController_Def.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"autoConnectDevices"), aname="_autoConnectDevices", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ehciEnabled"), aname="_ehciEnabled", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualController_Def not in ns0.VirtualUSBController_Def.__bases__: - bases = list(ns0.VirtualUSBController_Def.__bases__) - bases.insert(0, ns0.VirtualController_Def) - ns0.VirtualUSBController_Def.__bases__ = tuple(bases) - - ns0.VirtualController_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualUSBControllerOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualUSBControllerOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualUSBControllerOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"autoConnectDevices"), aname="_autoConnectDevices", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"ehciSupported"), aname="_ehciSupported", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualControllerOption_Def not in ns0.VirtualUSBControllerOption_Def.__bases__: - bases = list(ns0.VirtualUSBControllerOption_Def.__bases__) - bases.insert(0, ns0.VirtualControllerOption_Def) - ns0.VirtualUSBControllerOption_Def.__bases__ = tuple(bases) - - ns0.VirtualControllerOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualUSBUSBBackingOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualUSBUSBBackingOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualUSBUSBBackingOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceDeviceBackingOption_Def not in ns0.VirtualUSBUSBBackingOption_Def.__bases__: - bases = list(ns0.VirtualUSBUSBBackingOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceDeviceBackingOption_Def) - ns0.VirtualUSBUSBBackingOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceDeviceBackingOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualUSBOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualUSBOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualUSBOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualUSBOption_Def.__bases__: - bases = list(ns0.VirtualUSBOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualUSBOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineVMCIDevice_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineVMCIDevice") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineVMCIDevice_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"id"), aname="_id", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"allowUnrestrictedCommunication"), aname="_allowUnrestrictedCommunication", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualMachineVMCIDevice_Def.__bases__: - bases = list(ns0.VirtualMachineVMCIDevice_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualMachineVMCIDevice_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineVMCIDeviceOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineVMCIDeviceOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineVMCIDeviceOption_Def.schema - TClist = [GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"allowUnrestrictedCommunication"), aname="_allowUnrestrictedCommunication", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualMachineVMCIDeviceOption_Def.__bases__: - bases = list(ns0.VirtualMachineVMCIDeviceOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualMachineVMCIDeviceOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineVMIROM_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineVMIROM") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineVMIROM_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualMachineVMIROM_Def.__bases__: - bases = list(ns0.VirtualMachineVMIROM_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualMachineVMIROM_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVMIROMOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVMIROMOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVMIROMOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualVMIROMOption_Def.__bases__: - bases = list(ns0.VirtualVMIROMOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualVMIROMOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualMachineVideoCard_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualMachineVideoCard") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualMachineVideoCard_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"videoRamSizeInKB"), aname="_videoRamSizeInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"numDisplays"), aname="_numDisplays", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"enable3DSupport"), aname="_enable3DSupport", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDevice_Def not in ns0.VirtualMachineVideoCard_Def.__bases__: - bases = list(ns0.VirtualMachineVideoCard_Def.__bases__) - bases.insert(0, ns0.VirtualDevice_Def) - ns0.VirtualMachineVideoCard_Def.__bases__ = tuple(bases) - - ns0.VirtualDevice_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVideoCardOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVideoCardOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVideoCardOption_Def.schema - TClist = [GTD("urn:vim25","LongOption",lazy=True)(pname=(ns,"videoRamSizeInKB"), aname="_videoRamSizeInKB", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","IntOption",lazy=True)(pname=(ns,"numDisplays"), aname="_numDisplays", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"useAutoDetect"), aname="_useAutoDetect", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("urn:vim25","BoolOption",lazy=True)(pname=(ns,"support3D"), aname="_support3D", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualDeviceOption_Def not in ns0.VirtualVideoCardOption_Def.__bases__: - bases = list(ns0.VirtualVideoCardOption_Def.__bases__) - bases.insert(0, ns0.VirtualDeviceOption_Def) - ns0.VirtualVideoCardOption_Def.__bases__ = tuple(bases) - - ns0.VirtualDeviceOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVmxnet_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVmxnet") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVmxnet_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualEthernetCard_Def not in ns0.VirtualVmxnet_Def.__bases__: - bases = list(ns0.VirtualVmxnet_Def.__bases__) - bases.insert(0, ns0.VirtualEthernetCard_Def) - ns0.VirtualVmxnet_Def.__bases__ = tuple(bases) - - ns0.VirtualEthernetCard_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVmxnet2_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVmxnet2") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVmxnet2_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualVmxnet_Def not in ns0.VirtualVmxnet2_Def.__bases__: - bases = list(ns0.VirtualVmxnet2_Def.__bases__) - bases.insert(0, ns0.VirtualVmxnet_Def) - ns0.VirtualVmxnet2_Def.__bases__ = tuple(bases) - - ns0.VirtualVmxnet_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVmxnet2Option_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVmxnet2Option") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVmxnet2Option_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualVmxnetOption_Def not in ns0.VirtualVmxnet2Option_Def.__bases__: - bases = list(ns0.VirtualVmxnet2Option_Def.__bases__) - bases.insert(0, ns0.VirtualVmxnetOption_Def) - ns0.VirtualVmxnet2Option_Def.__bases__ = tuple(bases) - - ns0.VirtualVmxnetOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVmxnet3_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVmxnet3") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVmxnet3_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualVmxnet_Def not in ns0.VirtualVmxnet3_Def.__bases__: - bases = list(ns0.VirtualVmxnet3_Def.__bases__) - bases.insert(0, ns0.VirtualVmxnet_Def) - ns0.VirtualVmxnet3_Def.__bases__ = tuple(bases) - - ns0.VirtualVmxnet_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVmxnet3Option_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVmxnet3Option") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVmxnet3Option_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualVmxnetOption_Def not in ns0.VirtualVmxnet3Option_Def.__bases__: - bases = list(ns0.VirtualVmxnet3Option_Def.__bases__) - bases.insert(0, ns0.VirtualVmxnetOption_Def) - ns0.VirtualVmxnet3Option_Def.__bases__ = tuple(bases) - - ns0.VirtualVmxnetOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class VirtualVmxnetOption_Def(TypeDefinition): - #complexType/complexContent extension - schema = "urn:vim25" - type = (schema, "VirtualVmxnetOption") - def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw): - ns = ns0.VirtualVmxnetOption_Def.schema - TClist = [] - attributes = self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - if ns0.VirtualEthernetCardOption_Def not in ns0.VirtualVmxnetOption_Def.__bases__: - bases = list(ns0.VirtualVmxnetOption_Def.__bases__) - bases.insert(0, ns0.VirtualEthernetCardOption_Def) - ns0.VirtualVmxnetOption_Def.__bases__ = tuple(bases) - - ns0.VirtualEthernetCardOption_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw) - - class ManagedObjectReference_Def(ZSI.TC.String, TypeDefinition): - # ComplexType/SimpleContent derivation of built-in type - schema = "urn:vim25" - type = (schema, "ManagedObjectReference") - def __init__(self, pname, **kw): - if getattr(self, "attribute_typecode_dict", None) is None: self.attribute_typecode_dict = {} - # attribute handling code - self.attribute_typecode_dict["type"] = ZSI.TC.String() - ZSI.TC.String.__init__(self, pname, **kw) - class Holder(str): - __metaclass__ = pyclass_type - typecode = self - self.pyclass = Holder - - class ArrayOfString_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfString") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfString_Def.schema - TClist = [ZSI.TC.String(pname=(ns,"string"), aname="_string", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._string = [] - return - Holder.__name__ = "ArrayOfString_Holder" - self.pyclass = Holder - - class ArrayOfAnyType_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfAnyType") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfAnyType_Def.schema - TClist = [ZSI.TC.AnyType(pname=(ns,"anyType"), aname="_anyType", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._anyType = [] - return - Holder.__name__ = "ArrayOfAnyType_Holder" - self.pyclass = Holder - - class ArrayOfManagedObjectReference_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfManagedObjectReference") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfManagedObjectReference_Def.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"ManagedObjectReference"), aname="_ManagedObjectReference", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._ManagedObjectReference = [] - return - Holder.__name__ = "ArrayOfManagedObjectReference_Holder" - self.pyclass = Holder - - class ArrayOfByte_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfByte") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfByte_Def.schema - TClist = [ZSI.TCnumbers.Ibyte(pname=(ns,"byte"), aname="_byte", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._byte = [] - return - Holder.__name__ = "ArrayOfByte_Holder" - self.pyclass = Holder - - class ArrayOfInt_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfInt") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfInt_Def.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"int"), aname="_int", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._int = [] - return - Holder.__name__ = "ArrayOfInt_Holder" - self.pyclass = Holder - - class ArrayOfLong_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfLong") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfLong_Def.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"long"), aname="_long", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._long = [] - return - Holder.__name__ = "ArrayOfLong_Holder" - self.pyclass = Holder - - class ArrayOfShort_Def(ZSI.TCcompound.ComplexType, TypeDefinition): - schema = "urn:vim25" - type = (schema, "ArrayOfShort") - def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw): - ns = ns0.ArrayOfShort_Def.schema - TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"short"), aname="_short", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - self.attribute_typecode_dict = attributes or {} - if extend: TClist += ofwhat - if restrict: TClist = ofwhat - ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._short = [] - return - Holder.__name__ = "ArrayOfShort_Holder" - self.pyclass = Holder - - class HostCommunicationFault_Dec(ElementDeclaration): - literal = "HostCommunicationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostCommunicationFault") - kw["aname"] = "_HostCommunicationFault" - if ns0.HostCommunication_Def not in ns0.HostCommunicationFault_Dec.__bases__: - bases = list(ns0.HostCommunicationFault_Dec.__bases__) - bases.insert(0, ns0.HostCommunication_Def) - ns0.HostCommunicationFault_Dec.__bases__ = tuple(bases) - - ns0.HostCommunication_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostCommunicationFault_Dec_Holder" - - class HostNotConnectedFault_Dec(ElementDeclaration): - literal = "HostNotConnectedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostNotConnectedFault") - kw["aname"] = "_HostNotConnectedFault" - if ns0.HostNotConnected_Def not in ns0.HostNotConnectedFault_Dec.__bases__: - bases = list(ns0.HostNotConnectedFault_Dec.__bases__) - bases.insert(0, ns0.HostNotConnected_Def) - ns0.HostNotConnectedFault_Dec.__bases__ = tuple(bases) - - ns0.HostNotConnected_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostNotConnectedFault_Dec_Holder" - - class HostNotReachableFault_Dec(ElementDeclaration): - literal = "HostNotReachableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostNotReachableFault") - kw["aname"] = "_HostNotReachableFault" - if ns0.HostNotReachable_Def not in ns0.HostNotReachableFault_Dec.__bases__: - bases = list(ns0.HostNotReachableFault_Dec.__bases__) - bases.insert(0, ns0.HostNotReachable_Def) - ns0.HostNotReachableFault_Dec.__bases__ = tuple(bases) - - ns0.HostNotReachable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostNotReachableFault_Dec_Holder" - - class InvalidArgumentFault_Dec(ElementDeclaration): - literal = "InvalidArgumentFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidArgumentFault") - kw["aname"] = "_InvalidArgumentFault" - if ns0.InvalidArgument_Def not in ns0.InvalidArgumentFault_Dec.__bases__: - bases = list(ns0.InvalidArgumentFault_Dec.__bases__) - bases.insert(0, ns0.InvalidArgument_Def) - ns0.InvalidArgumentFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidArgument_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidArgumentFault_Dec_Holder" - - class InvalidRequestFault_Dec(ElementDeclaration): - literal = "InvalidRequestFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidRequestFault") - kw["aname"] = "_InvalidRequestFault" - if ns0.InvalidRequest_Def not in ns0.InvalidRequestFault_Dec.__bases__: - bases = list(ns0.InvalidRequestFault_Dec.__bases__) - bases.insert(0, ns0.InvalidRequest_Def) - ns0.InvalidRequestFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidRequest_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidRequestFault_Dec_Holder" - - class InvalidTypeFault_Dec(ElementDeclaration): - literal = "InvalidTypeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidTypeFault") - kw["aname"] = "_InvalidTypeFault" - if ns0.InvalidType_Def not in ns0.InvalidTypeFault_Dec.__bases__: - bases = list(ns0.InvalidTypeFault_Dec.__bases__) - bases.insert(0, ns0.InvalidType_Def) - ns0.InvalidTypeFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidTypeFault_Dec_Holder" - - class ManagedObjectNotFoundFault_Dec(ElementDeclaration): - literal = "ManagedObjectNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ManagedObjectNotFoundFault") - kw["aname"] = "_ManagedObjectNotFoundFault" - if ns0.ManagedObjectNotFound_Def not in ns0.ManagedObjectNotFoundFault_Dec.__bases__: - bases = list(ns0.ManagedObjectNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.ManagedObjectNotFound_Def) - ns0.ManagedObjectNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.ManagedObjectNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ManagedObjectNotFoundFault_Dec_Holder" - - class MethodNotFoundFault_Dec(ElementDeclaration): - literal = "MethodNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MethodNotFoundFault") - kw["aname"] = "_MethodNotFoundFault" - if ns0.MethodNotFound_Def not in ns0.MethodNotFoundFault_Dec.__bases__: - bases = list(ns0.MethodNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.MethodNotFound_Def) - ns0.MethodNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.MethodNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MethodNotFoundFault_Dec_Holder" - - class NotEnoughLicensesFault_Dec(ElementDeclaration): - literal = "NotEnoughLicensesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotEnoughLicensesFault") - kw["aname"] = "_NotEnoughLicensesFault" - if ns0.NotEnoughLicenses_Def not in ns0.NotEnoughLicensesFault_Dec.__bases__: - bases = list(ns0.NotEnoughLicensesFault_Dec.__bases__) - bases.insert(0, ns0.NotEnoughLicenses_Def) - ns0.NotEnoughLicensesFault_Dec.__bases__ = tuple(bases) - - ns0.NotEnoughLicenses_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotEnoughLicensesFault_Dec_Holder" - - class NotImplementedFault_Dec(ElementDeclaration): - literal = "NotImplementedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotImplementedFault") - kw["aname"] = "_NotImplementedFault" - if ns0.NotImplemented_Def not in ns0.NotImplementedFault_Dec.__bases__: - bases = list(ns0.NotImplementedFault_Dec.__bases__) - bases.insert(0, ns0.NotImplemented_Def) - ns0.NotImplementedFault_Dec.__bases__ = tuple(bases) - - ns0.NotImplemented_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotImplementedFault_Dec_Holder" - - class NotSupportedFault_Dec(ElementDeclaration): - literal = "NotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotSupportedFault") - kw["aname"] = "_NotSupportedFault" - if ns0.NotSupported_Def not in ns0.NotSupportedFault_Dec.__bases__: - bases = list(ns0.NotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.NotSupported_Def) - ns0.NotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.NotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotSupportedFault_Dec_Holder" - - class RequestCanceledFault_Dec(ElementDeclaration): - literal = "RequestCanceledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RequestCanceledFault") - kw["aname"] = "_RequestCanceledFault" - if ns0.RequestCanceled_Def not in ns0.RequestCanceledFault_Dec.__bases__: - bases = list(ns0.RequestCanceledFault_Dec.__bases__) - bases.insert(0, ns0.RequestCanceled_Def) - ns0.RequestCanceledFault_Dec.__bases__ = tuple(bases) - - ns0.RequestCanceled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RequestCanceledFault_Dec_Holder" - - class SecurityErrorFault_Dec(ElementDeclaration): - literal = "SecurityErrorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SecurityErrorFault") - kw["aname"] = "_SecurityErrorFault" - if ns0.SecurityError_Def not in ns0.SecurityErrorFault_Dec.__bases__: - bases = list(ns0.SecurityErrorFault_Dec.__bases__) - bases.insert(0, ns0.SecurityError_Def) - ns0.SecurityErrorFault_Dec.__bases__ = tuple(bases) - - ns0.SecurityError_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SecurityErrorFault_Dec_Holder" - - class SystemErrorFault_Dec(ElementDeclaration): - literal = "SystemErrorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SystemErrorFault") - kw["aname"] = "_SystemErrorFault" - if ns0.SystemError_Def not in ns0.SystemErrorFault_Dec.__bases__: - bases = list(ns0.SystemErrorFault_Dec.__bases__) - bases.insert(0, ns0.SystemError_Def) - ns0.SystemErrorFault_Dec.__bases__ = tuple(bases) - - ns0.SystemError_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SystemErrorFault_Dec_Holder" - - class UnexpectedFaultFault_Dec(ElementDeclaration): - literal = "UnexpectedFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnexpectedFaultFault") - kw["aname"] = "_UnexpectedFaultFault" - if ns0.UnexpectedFault_Def not in ns0.UnexpectedFaultFault_Dec.__bases__: - bases = list(ns0.UnexpectedFaultFault_Dec.__bases__) - bases.insert(0, ns0.UnexpectedFault_Def) - ns0.UnexpectedFaultFault_Dec.__bases__ = tuple(bases) - - ns0.UnexpectedFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnexpectedFaultFault_Dec_Holder" - - class InvalidCollectorVersionFault_Dec(ElementDeclaration): - literal = "InvalidCollectorVersionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidCollectorVersionFault") - kw["aname"] = "_InvalidCollectorVersionFault" - if ns0.InvalidCollectorVersion_Def not in ns0.InvalidCollectorVersionFault_Dec.__bases__: - bases = list(ns0.InvalidCollectorVersionFault_Dec.__bases__) - bases.insert(0, ns0.InvalidCollectorVersion_Def) - ns0.InvalidCollectorVersionFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidCollectorVersion_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidCollectorVersionFault_Dec_Holder" - - class InvalidPropertyFault_Dec(ElementDeclaration): - literal = "InvalidPropertyFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidPropertyFault") - kw["aname"] = "_InvalidPropertyFault" - if ns0.InvalidProperty_Def not in ns0.InvalidPropertyFault_Dec.__bases__: - bases = list(ns0.InvalidPropertyFault_Dec.__bases__) - bases.insert(0, ns0.InvalidProperty_Def) - ns0.InvalidPropertyFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidProperty_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidPropertyFault_Dec_Holder" - - class DestroyPropertyFilter_Dec(ElementDeclaration): - literal = "DestroyPropertyFilter" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestroyPropertyFilter") - kw["aname"] = "_DestroyPropertyFilter" - if ns0.DestroyPropertyFilterRequestType_Def not in ns0.DestroyPropertyFilter_Dec.__bases__: - bases = list(ns0.DestroyPropertyFilter_Dec.__bases__) - bases.insert(0, ns0.DestroyPropertyFilterRequestType_Def) - ns0.DestroyPropertyFilter_Dec.__bases__ = tuple(bases) - - ns0.DestroyPropertyFilterRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestroyPropertyFilter_Dec_Holder" - - class DestroyPropertyFilterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyPropertyFilterResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyPropertyFilterResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyPropertyFilterResponse") - kw["aname"] = "_DestroyPropertyFilterResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyPropertyFilterResponse_Holder" - self.pyclass = Holder - - class CreateFilter_Dec(ElementDeclaration): - literal = "CreateFilter" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateFilter") - kw["aname"] = "_CreateFilter" - if ns0.CreateFilterRequestType_Def not in ns0.CreateFilter_Dec.__bases__: - bases = list(ns0.CreateFilter_Dec.__bases__) - bases.insert(0, ns0.CreateFilterRequestType_Def) - ns0.CreateFilter_Dec.__bases__ = tuple(bases) - - ns0.CreateFilterRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateFilter_Dec_Holder" - - class CreateFilterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateFilterResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateFilterResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateFilterResponse") - kw["aname"] = "_CreateFilterResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateFilterResponse_Holder" - self.pyclass = Holder - - class RetrieveProperties_Dec(ElementDeclaration): - literal = "RetrieveProperties" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveProperties") - kw["aname"] = "_RetrieveProperties" - if ns0.RetrievePropertiesRequestType_Def not in ns0.RetrieveProperties_Dec.__bases__: - bases = list(ns0.RetrieveProperties_Dec.__bases__) - bases.insert(0, ns0.RetrievePropertiesRequestType_Def) - ns0.RetrieveProperties_Dec.__bases__ = tuple(bases) - - ns0.RetrievePropertiesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveProperties_Dec_Holder" - - class RetrievePropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrievePropertiesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrievePropertiesResponse_Dec.schema - TClist = [GTD("urn:vim25","ObjectContent",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrievePropertiesResponse") - kw["aname"] = "_RetrievePropertiesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrievePropertiesResponse_Holder" - self.pyclass = Holder - - class CheckForUpdates_Dec(ElementDeclaration): - literal = "CheckForUpdates" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckForUpdates") - kw["aname"] = "_CheckForUpdates" - if ns0.CheckForUpdatesRequestType_Def not in ns0.CheckForUpdates_Dec.__bases__: - bases = list(ns0.CheckForUpdates_Dec.__bases__) - bases.insert(0, ns0.CheckForUpdatesRequestType_Def) - ns0.CheckForUpdates_Dec.__bases__ = tuple(bases) - - ns0.CheckForUpdatesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckForUpdates_Dec_Holder" - - class CheckForUpdatesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckForUpdatesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckForUpdatesResponse_Dec.schema - TClist = [GTD("urn:vim25","UpdateSet",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckForUpdatesResponse") - kw["aname"] = "_CheckForUpdatesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CheckForUpdatesResponse_Holder" - self.pyclass = Holder - - class WaitForUpdates_Dec(ElementDeclaration): - literal = "WaitForUpdates" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","WaitForUpdates") - kw["aname"] = "_WaitForUpdates" - if ns0.WaitForUpdatesRequestType_Def not in ns0.WaitForUpdates_Dec.__bases__: - bases = list(ns0.WaitForUpdates_Dec.__bases__) - bases.insert(0, ns0.WaitForUpdatesRequestType_Def) - ns0.WaitForUpdates_Dec.__bases__ = tuple(bases) - - ns0.WaitForUpdatesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "WaitForUpdates_Dec_Holder" - - class WaitForUpdatesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "WaitForUpdatesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.WaitForUpdatesResponse_Dec.schema - TClist = [GTD("urn:vim25","UpdateSet",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","WaitForUpdatesResponse") - kw["aname"] = "_WaitForUpdatesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "WaitForUpdatesResponse_Holder" - self.pyclass = Holder - - class CancelWaitForUpdates_Dec(ElementDeclaration): - literal = "CancelWaitForUpdates" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CancelWaitForUpdates") - kw["aname"] = "_CancelWaitForUpdates" - if ns0.CancelWaitForUpdatesRequestType_Def not in ns0.CancelWaitForUpdates_Dec.__bases__: - bases = list(ns0.CancelWaitForUpdates_Dec.__bases__) - bases.insert(0, ns0.CancelWaitForUpdatesRequestType_Def) - ns0.CancelWaitForUpdates_Dec.__bases__ = tuple(bases) - - ns0.CancelWaitForUpdatesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CancelWaitForUpdates_Dec_Holder" - - class CancelWaitForUpdatesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CancelWaitForUpdatesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CancelWaitForUpdatesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CancelWaitForUpdatesResponse") - kw["aname"] = "_CancelWaitForUpdatesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CancelWaitForUpdatesResponse_Holder" - self.pyclass = Holder - - class MethodFaultFault_Dec(ElementDeclaration): - literal = "MethodFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MethodFaultFault") - kw["aname"] = "_MethodFaultFault" - if ns0.MethodFault_Def not in ns0.MethodFaultFault_Dec.__bases__: - bases = list(ns0.MethodFaultFault_Dec.__bases__) - bases.insert(0, ns0.MethodFault_Def) - ns0.MethodFaultFault_Dec.__bases__ = tuple(bases) - - ns0.MethodFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MethodFaultFault_Dec_Holder" - - class RuntimeFaultFault_Dec(ElementDeclaration): - literal = "RuntimeFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RuntimeFaultFault") - kw["aname"] = "_RuntimeFaultFault" - if ns0.RuntimeFault_Def not in ns0.RuntimeFaultFault_Dec.__bases__: - bases = list(ns0.RuntimeFaultFault_Dec.__bases__) - bases.insert(0, ns0.RuntimeFault_Def) - ns0.RuntimeFaultFault_Dec.__bases__ = tuple(bases) - - ns0.RuntimeFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RuntimeFaultFault_Dec_Holder" - - class AddAuthorizationRole_Dec(ElementDeclaration): - literal = "AddAuthorizationRole" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddAuthorizationRole") - kw["aname"] = "_AddAuthorizationRole" - if ns0.AddAuthorizationRoleRequestType_Def not in ns0.AddAuthorizationRole_Dec.__bases__: - bases = list(ns0.AddAuthorizationRole_Dec.__bases__) - bases.insert(0, ns0.AddAuthorizationRoleRequestType_Def) - ns0.AddAuthorizationRole_Dec.__bases__ = tuple(bases) - - ns0.AddAuthorizationRoleRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddAuthorizationRole_Dec_Holder" - - class AddAuthorizationRoleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddAuthorizationRoleResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddAuthorizationRoleResponse_Dec.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddAuthorizationRoleResponse") - kw["aname"] = "_AddAuthorizationRoleResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddAuthorizationRoleResponse_Holder" - self.pyclass = Holder - - class RemoveAuthorizationRole_Dec(ElementDeclaration): - literal = "RemoveAuthorizationRole" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveAuthorizationRole") - kw["aname"] = "_RemoveAuthorizationRole" - if ns0.RemoveAuthorizationRoleRequestType_Def not in ns0.RemoveAuthorizationRole_Dec.__bases__: - bases = list(ns0.RemoveAuthorizationRole_Dec.__bases__) - bases.insert(0, ns0.RemoveAuthorizationRoleRequestType_Def) - ns0.RemoveAuthorizationRole_Dec.__bases__ = tuple(bases) - - ns0.RemoveAuthorizationRoleRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveAuthorizationRole_Dec_Holder" - - class RemoveAuthorizationRoleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveAuthorizationRoleResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveAuthorizationRoleResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveAuthorizationRoleResponse") - kw["aname"] = "_RemoveAuthorizationRoleResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveAuthorizationRoleResponse_Holder" - self.pyclass = Holder - - class UpdateAuthorizationRole_Dec(ElementDeclaration): - literal = "UpdateAuthorizationRole" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateAuthorizationRole") - kw["aname"] = "_UpdateAuthorizationRole" - if ns0.UpdateAuthorizationRoleRequestType_Def not in ns0.UpdateAuthorizationRole_Dec.__bases__: - bases = list(ns0.UpdateAuthorizationRole_Dec.__bases__) - bases.insert(0, ns0.UpdateAuthorizationRoleRequestType_Def) - ns0.UpdateAuthorizationRole_Dec.__bases__ = tuple(bases) - - ns0.UpdateAuthorizationRoleRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateAuthorizationRole_Dec_Holder" - - class UpdateAuthorizationRoleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateAuthorizationRoleResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateAuthorizationRoleResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateAuthorizationRoleResponse") - kw["aname"] = "_UpdateAuthorizationRoleResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateAuthorizationRoleResponse_Holder" - self.pyclass = Holder - - class MergePermissions_Dec(ElementDeclaration): - literal = "MergePermissions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MergePermissions") - kw["aname"] = "_MergePermissions" - if ns0.MergePermissionsRequestType_Def not in ns0.MergePermissions_Dec.__bases__: - bases = list(ns0.MergePermissions_Dec.__bases__) - bases.insert(0, ns0.MergePermissionsRequestType_Def) - ns0.MergePermissions_Dec.__bases__ = tuple(bases) - - ns0.MergePermissionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MergePermissions_Dec_Holder" - - class MergePermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MergePermissionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MergePermissionsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MergePermissionsResponse") - kw["aname"] = "_MergePermissionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MergePermissionsResponse_Holder" - self.pyclass = Holder - - class RetrieveRolePermissions_Dec(ElementDeclaration): - literal = "RetrieveRolePermissions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveRolePermissions") - kw["aname"] = "_RetrieveRolePermissions" - if ns0.RetrieveRolePermissionsRequestType_Def not in ns0.RetrieveRolePermissions_Dec.__bases__: - bases = list(ns0.RetrieveRolePermissions_Dec.__bases__) - bases.insert(0, ns0.RetrieveRolePermissionsRequestType_Def) - ns0.RetrieveRolePermissions_Dec.__bases__ = tuple(bases) - - ns0.RetrieveRolePermissionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveRolePermissions_Dec_Holder" - - class RetrieveRolePermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveRolePermissionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveRolePermissionsResponse_Dec.schema - TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveRolePermissionsResponse") - kw["aname"] = "_RetrieveRolePermissionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveRolePermissionsResponse_Holder" - self.pyclass = Holder - - class RetrieveEntityPermissions_Dec(ElementDeclaration): - literal = "RetrieveEntityPermissions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveEntityPermissions") - kw["aname"] = "_RetrieveEntityPermissions" - if ns0.RetrieveEntityPermissionsRequestType_Def not in ns0.RetrieveEntityPermissions_Dec.__bases__: - bases = list(ns0.RetrieveEntityPermissions_Dec.__bases__) - bases.insert(0, ns0.RetrieveEntityPermissionsRequestType_Def) - ns0.RetrieveEntityPermissions_Dec.__bases__ = tuple(bases) - - ns0.RetrieveEntityPermissionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveEntityPermissions_Dec_Holder" - - class RetrieveEntityPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveEntityPermissionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveEntityPermissionsResponse_Dec.schema - TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveEntityPermissionsResponse") - kw["aname"] = "_RetrieveEntityPermissionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveEntityPermissionsResponse_Holder" - self.pyclass = Holder - - class RetrieveAllPermissions_Dec(ElementDeclaration): - literal = "RetrieveAllPermissions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveAllPermissions") - kw["aname"] = "_RetrieveAllPermissions" - if ns0.RetrieveAllPermissionsRequestType_Def not in ns0.RetrieveAllPermissions_Dec.__bases__: - bases = list(ns0.RetrieveAllPermissions_Dec.__bases__) - bases.insert(0, ns0.RetrieveAllPermissionsRequestType_Def) - ns0.RetrieveAllPermissions_Dec.__bases__ = tuple(bases) - - ns0.RetrieveAllPermissionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveAllPermissions_Dec_Holder" - - class RetrieveAllPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveAllPermissionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveAllPermissionsResponse_Dec.schema - TClist = [GTD("urn:vim25","Permission",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveAllPermissionsResponse") - kw["aname"] = "_RetrieveAllPermissionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveAllPermissionsResponse_Holder" - self.pyclass = Holder - - class SetEntityPermissions_Dec(ElementDeclaration): - literal = "SetEntityPermissions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetEntityPermissions") - kw["aname"] = "_SetEntityPermissions" - if ns0.SetEntityPermissionsRequestType_Def not in ns0.SetEntityPermissions_Dec.__bases__: - bases = list(ns0.SetEntityPermissions_Dec.__bases__) - bases.insert(0, ns0.SetEntityPermissionsRequestType_Def) - ns0.SetEntityPermissions_Dec.__bases__ = tuple(bases) - - ns0.SetEntityPermissionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetEntityPermissions_Dec_Holder" - - class SetEntityPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetEntityPermissionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetEntityPermissionsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetEntityPermissionsResponse") - kw["aname"] = "_SetEntityPermissionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetEntityPermissionsResponse_Holder" - self.pyclass = Holder - - class ResetEntityPermissions_Dec(ElementDeclaration): - literal = "ResetEntityPermissions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetEntityPermissions") - kw["aname"] = "_ResetEntityPermissions" - if ns0.ResetEntityPermissionsRequestType_Def not in ns0.ResetEntityPermissions_Dec.__bases__: - bases = list(ns0.ResetEntityPermissions_Dec.__bases__) - bases.insert(0, ns0.ResetEntityPermissionsRequestType_Def) - ns0.ResetEntityPermissions_Dec.__bases__ = tuple(bases) - - ns0.ResetEntityPermissionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetEntityPermissions_Dec_Holder" - - class ResetEntityPermissionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetEntityPermissionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetEntityPermissionsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetEntityPermissionsResponse") - kw["aname"] = "_ResetEntityPermissionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetEntityPermissionsResponse_Holder" - self.pyclass = Holder - - class RemoveEntityPermission_Dec(ElementDeclaration): - literal = "RemoveEntityPermission" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveEntityPermission") - kw["aname"] = "_RemoveEntityPermission" - if ns0.RemoveEntityPermissionRequestType_Def not in ns0.RemoveEntityPermission_Dec.__bases__: - bases = list(ns0.RemoveEntityPermission_Dec.__bases__) - bases.insert(0, ns0.RemoveEntityPermissionRequestType_Def) - ns0.RemoveEntityPermission_Dec.__bases__ = tuple(bases) - - ns0.RemoveEntityPermissionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveEntityPermission_Dec_Holder" - - class RemoveEntityPermissionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveEntityPermissionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveEntityPermissionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveEntityPermissionResponse") - kw["aname"] = "_RemoveEntityPermissionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveEntityPermissionResponse_Holder" - self.pyclass = Holder - - class ReconfigureCluster_Dec(ElementDeclaration): - literal = "ReconfigureCluster" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureCluster") - kw["aname"] = "_ReconfigureCluster" - if ns0.ReconfigureClusterRequestType_Def not in ns0.ReconfigureCluster_Dec.__bases__: - bases = list(ns0.ReconfigureCluster_Dec.__bases__) - bases.insert(0, ns0.ReconfigureClusterRequestType_Def) - ns0.ReconfigureCluster_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureClusterRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureCluster_Dec_Holder" - - class ReconfigureClusterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureClusterResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureClusterResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureClusterResponse") - kw["aname"] = "_ReconfigureClusterResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureClusterResponse_Holder" - self.pyclass = Holder - - class ReconfigureCluster_Task_Dec(ElementDeclaration): - literal = "ReconfigureCluster_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureCluster_Task") - kw["aname"] = "_ReconfigureCluster_Task" - if ns0.ReconfigureClusterRequestType_Def not in ns0.ReconfigureCluster_Task_Dec.__bases__: - bases = list(ns0.ReconfigureCluster_Task_Dec.__bases__) - bases.insert(0, ns0.ReconfigureClusterRequestType_Def) - ns0.ReconfigureCluster_Task_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureClusterRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureCluster_Task_Dec_Holder" - - class ReconfigureCluster_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureCluster_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureCluster_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReconfigureCluster_TaskResponse") - kw["aname"] = "_ReconfigureCluster_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ReconfigureCluster_TaskResponse_Holder" - self.pyclass = Holder - - class ApplyRecommendation_Dec(ElementDeclaration): - literal = "ApplyRecommendation" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ApplyRecommendation") - kw["aname"] = "_ApplyRecommendation" - if ns0.ApplyRecommendationRequestType_Def not in ns0.ApplyRecommendation_Dec.__bases__: - bases = list(ns0.ApplyRecommendation_Dec.__bases__) - bases.insert(0, ns0.ApplyRecommendationRequestType_Def) - ns0.ApplyRecommendation_Dec.__bases__ = tuple(bases) - - ns0.ApplyRecommendationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ApplyRecommendation_Dec_Holder" - - class ApplyRecommendationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ApplyRecommendationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ApplyRecommendationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ApplyRecommendationResponse") - kw["aname"] = "_ApplyRecommendationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ApplyRecommendationResponse_Holder" - self.pyclass = Holder - - class RecommendHostsForVm_Dec(ElementDeclaration): - literal = "RecommendHostsForVm" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RecommendHostsForVm") - kw["aname"] = "_RecommendHostsForVm" - if ns0.RecommendHostsForVmRequestType_Def not in ns0.RecommendHostsForVm_Dec.__bases__: - bases = list(ns0.RecommendHostsForVm_Dec.__bases__) - bases.insert(0, ns0.RecommendHostsForVmRequestType_Def) - ns0.RecommendHostsForVm_Dec.__bases__ = tuple(bases) - - ns0.RecommendHostsForVmRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RecommendHostsForVm_Dec_Holder" - - class RecommendHostsForVmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RecommendHostsForVmResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RecommendHostsForVmResponse_Dec.schema - TClist = [GTD("urn:vim25","ClusterHostRecommendation",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RecommendHostsForVmResponse") - kw["aname"] = "_RecommendHostsForVmResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RecommendHostsForVmResponse_Holder" - self.pyclass = Holder - - class AddHost_Dec(ElementDeclaration): - literal = "AddHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddHost") - kw["aname"] = "_AddHost" - if ns0.AddHostRequestType_Def not in ns0.AddHost_Dec.__bases__: - bases = list(ns0.AddHost_Dec.__bases__) - bases.insert(0, ns0.AddHostRequestType_Def) - ns0.AddHost_Dec.__bases__ = tuple(bases) - - ns0.AddHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddHost_Dec_Holder" - - class AddHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddHostResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddHostResponse") - kw["aname"] = "_AddHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddHostResponse_Holder" - self.pyclass = Holder - - class AddHost_Task_Dec(ElementDeclaration): - literal = "AddHost_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddHost_Task") - kw["aname"] = "_AddHost_Task" - if ns0.AddHostRequestType_Def not in ns0.AddHost_Task_Dec.__bases__: - bases = list(ns0.AddHost_Task_Dec.__bases__) - bases.insert(0, ns0.AddHostRequestType_Def) - ns0.AddHost_Task_Dec.__bases__ = tuple(bases) - - ns0.AddHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddHost_Task_Dec_Holder" - - class AddHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddHost_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddHost_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddHost_TaskResponse") - kw["aname"] = "_AddHost_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddHost_TaskResponse_Holder" - self.pyclass = Holder - - class MoveInto_Dec(ElementDeclaration): - literal = "MoveInto" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveInto") - kw["aname"] = "_MoveInto" - if ns0.MoveIntoRequestType_Def not in ns0.MoveInto_Dec.__bases__: - bases = list(ns0.MoveInto_Dec.__bases__) - bases.insert(0, ns0.MoveIntoRequestType_Def) - ns0.MoveInto_Dec.__bases__ = tuple(bases) - - ns0.MoveIntoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveInto_Dec_Holder" - - class MoveIntoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveIntoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveIntoResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MoveIntoResponse") - kw["aname"] = "_MoveIntoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MoveIntoResponse_Holder" - self.pyclass = Holder - - class MoveInto_Task_Dec(ElementDeclaration): - literal = "MoveInto_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveInto_Task") - kw["aname"] = "_MoveInto_Task" - if ns0.MoveIntoRequestType_Def not in ns0.MoveInto_Task_Dec.__bases__: - bases = list(ns0.MoveInto_Task_Dec.__bases__) - bases.insert(0, ns0.MoveIntoRequestType_Def) - ns0.MoveInto_Task_Dec.__bases__ = tuple(bases) - - ns0.MoveIntoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveInto_Task_Dec_Holder" - - class MoveInto_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveInto_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveInto_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MoveInto_TaskResponse") - kw["aname"] = "_MoveInto_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MoveInto_TaskResponse_Holder" - self.pyclass = Holder - - class MoveHostInto_Dec(ElementDeclaration): - literal = "MoveHostInto" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveHostInto") - kw["aname"] = "_MoveHostInto" - if ns0.MoveHostIntoRequestType_Def not in ns0.MoveHostInto_Dec.__bases__: - bases = list(ns0.MoveHostInto_Dec.__bases__) - bases.insert(0, ns0.MoveHostIntoRequestType_Def) - ns0.MoveHostInto_Dec.__bases__ = tuple(bases) - - ns0.MoveHostIntoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveHostInto_Dec_Holder" - - class MoveHostIntoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveHostIntoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveHostIntoResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MoveHostIntoResponse") - kw["aname"] = "_MoveHostIntoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MoveHostIntoResponse_Holder" - self.pyclass = Holder - - class MoveHostInto_Task_Dec(ElementDeclaration): - literal = "MoveHostInto_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveHostInto_Task") - kw["aname"] = "_MoveHostInto_Task" - if ns0.MoveHostIntoRequestType_Def not in ns0.MoveHostInto_Task_Dec.__bases__: - bases = list(ns0.MoveHostInto_Task_Dec.__bases__) - bases.insert(0, ns0.MoveHostIntoRequestType_Def) - ns0.MoveHostInto_Task_Dec.__bases__ = tuple(bases) - - ns0.MoveHostIntoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveHostInto_Task_Dec_Holder" - - class MoveHostInto_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveHostInto_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveHostInto_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MoveHostInto_TaskResponse") - kw["aname"] = "_MoveHostInto_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MoveHostInto_TaskResponse_Holder" - self.pyclass = Holder - - class RefreshRecommendation_Dec(ElementDeclaration): - literal = "RefreshRecommendation" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshRecommendation") - kw["aname"] = "_RefreshRecommendation" - if ns0.RefreshRecommendationRequestType_Def not in ns0.RefreshRecommendation_Dec.__bases__: - bases = list(ns0.RefreshRecommendation_Dec.__bases__) - bases.insert(0, ns0.RefreshRecommendationRequestType_Def) - ns0.RefreshRecommendation_Dec.__bases__ = tuple(bases) - - ns0.RefreshRecommendationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshRecommendation_Dec_Holder" - - class RefreshRecommendationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshRecommendationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshRecommendationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshRecommendationResponse") - kw["aname"] = "_RefreshRecommendationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshRecommendationResponse_Holder" - self.pyclass = Holder - - class RetrieveDasAdvancedRuntimeInfo_Dec(ElementDeclaration): - literal = "RetrieveDasAdvancedRuntimeInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveDasAdvancedRuntimeInfo") - kw["aname"] = "_RetrieveDasAdvancedRuntimeInfo" - if ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def not in ns0.RetrieveDasAdvancedRuntimeInfo_Dec.__bases__: - bases = list(ns0.RetrieveDasAdvancedRuntimeInfo_Dec.__bases__) - bases.insert(0, ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def) - ns0.RetrieveDasAdvancedRuntimeInfo_Dec.__bases__ = tuple(bases) - - ns0.RetrieveDasAdvancedRuntimeInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveDasAdvancedRuntimeInfo_Dec_Holder" - - class RetrieveDasAdvancedRuntimeInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveDasAdvancedRuntimeInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveDasAdvancedRuntimeInfoResponse_Dec.schema - TClist = [GTD("urn:vim25","ClusterDasAdvancedRuntimeInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveDasAdvancedRuntimeInfoResponse") - kw["aname"] = "_RetrieveDasAdvancedRuntimeInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RetrieveDasAdvancedRuntimeInfoResponse_Holder" - self.pyclass = Holder - - class ReconfigureComputeResource_Dec(ElementDeclaration): - literal = "ReconfigureComputeResource" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureComputeResource") - kw["aname"] = "_ReconfigureComputeResource" - if ns0.ReconfigureComputeResourceRequestType_Def not in ns0.ReconfigureComputeResource_Dec.__bases__: - bases = list(ns0.ReconfigureComputeResource_Dec.__bases__) - bases.insert(0, ns0.ReconfigureComputeResourceRequestType_Def) - ns0.ReconfigureComputeResource_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureComputeResourceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureComputeResource_Dec_Holder" - - class ReconfigureComputeResourceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureComputeResourceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureComputeResourceResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureComputeResourceResponse") - kw["aname"] = "_ReconfigureComputeResourceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureComputeResourceResponse_Holder" - self.pyclass = Holder - - class ReconfigureComputeResource_Task_Dec(ElementDeclaration): - literal = "ReconfigureComputeResource_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureComputeResource_Task") - kw["aname"] = "_ReconfigureComputeResource_Task" - if ns0.ReconfigureComputeResourceRequestType_Def not in ns0.ReconfigureComputeResource_Task_Dec.__bases__: - bases = list(ns0.ReconfigureComputeResource_Task_Dec.__bases__) - bases.insert(0, ns0.ReconfigureComputeResourceRequestType_Def) - ns0.ReconfigureComputeResource_Task_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureComputeResourceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureComputeResource_Task_Dec_Holder" - - class ReconfigureComputeResource_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureComputeResource_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureComputeResource_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReconfigureComputeResource_TaskResponse") - kw["aname"] = "_ReconfigureComputeResource_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ReconfigureComputeResource_TaskResponse_Holder" - self.pyclass = Holder - - class AddCustomFieldDef_Dec(ElementDeclaration): - literal = "AddCustomFieldDef" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddCustomFieldDef") - kw["aname"] = "_AddCustomFieldDef" - if ns0.AddCustomFieldDefRequestType_Def not in ns0.AddCustomFieldDef_Dec.__bases__: - bases = list(ns0.AddCustomFieldDef_Dec.__bases__) - bases.insert(0, ns0.AddCustomFieldDefRequestType_Def) - ns0.AddCustomFieldDef_Dec.__bases__ = tuple(bases) - - ns0.AddCustomFieldDefRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddCustomFieldDef_Dec_Holder" - - class AddCustomFieldDefResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddCustomFieldDefResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddCustomFieldDefResponse_Dec.schema - TClist = [GTD("urn:vim25","CustomFieldDef",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddCustomFieldDefResponse") - kw["aname"] = "_AddCustomFieldDefResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddCustomFieldDefResponse_Holder" - self.pyclass = Holder - - class RemoveCustomFieldDef_Dec(ElementDeclaration): - literal = "RemoveCustomFieldDef" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveCustomFieldDef") - kw["aname"] = "_RemoveCustomFieldDef" - if ns0.RemoveCustomFieldDefRequestType_Def not in ns0.RemoveCustomFieldDef_Dec.__bases__: - bases = list(ns0.RemoveCustomFieldDef_Dec.__bases__) - bases.insert(0, ns0.RemoveCustomFieldDefRequestType_Def) - ns0.RemoveCustomFieldDef_Dec.__bases__ = tuple(bases) - - ns0.RemoveCustomFieldDefRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveCustomFieldDef_Dec_Holder" - - class RemoveCustomFieldDefResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveCustomFieldDefResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveCustomFieldDefResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveCustomFieldDefResponse") - kw["aname"] = "_RemoveCustomFieldDefResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveCustomFieldDefResponse_Holder" - self.pyclass = Holder - - class RenameCustomFieldDef_Dec(ElementDeclaration): - literal = "RenameCustomFieldDef" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RenameCustomFieldDef") - kw["aname"] = "_RenameCustomFieldDef" - if ns0.RenameCustomFieldDefRequestType_Def not in ns0.RenameCustomFieldDef_Dec.__bases__: - bases = list(ns0.RenameCustomFieldDef_Dec.__bases__) - bases.insert(0, ns0.RenameCustomFieldDefRequestType_Def) - ns0.RenameCustomFieldDef_Dec.__bases__ = tuple(bases) - - ns0.RenameCustomFieldDefRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RenameCustomFieldDef_Dec_Holder" - - class RenameCustomFieldDefResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RenameCustomFieldDefResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RenameCustomFieldDefResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RenameCustomFieldDefResponse") - kw["aname"] = "_RenameCustomFieldDefResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RenameCustomFieldDefResponse_Holder" - self.pyclass = Holder - - class SetField_Dec(ElementDeclaration): - literal = "SetField" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetField") - kw["aname"] = "_SetField" - if ns0.SetFieldRequestType_Def not in ns0.SetField_Dec.__bases__: - bases = list(ns0.SetField_Dec.__bases__) - bases.insert(0, ns0.SetFieldRequestType_Def) - ns0.SetField_Dec.__bases__ = tuple(bases) - - ns0.SetFieldRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetField_Dec_Holder" - - class SetFieldResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetFieldResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetFieldResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetFieldResponse") - kw["aname"] = "_SetFieldResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetFieldResponse_Holder" - self.pyclass = Holder - - class DoesCustomizationSpecExist_Dec(ElementDeclaration): - literal = "DoesCustomizationSpecExist" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DoesCustomizationSpecExist") - kw["aname"] = "_DoesCustomizationSpecExist" - if ns0.DoesCustomizationSpecExistRequestType_Def not in ns0.DoesCustomizationSpecExist_Dec.__bases__: - bases = list(ns0.DoesCustomizationSpecExist_Dec.__bases__) - bases.insert(0, ns0.DoesCustomizationSpecExistRequestType_Def) - ns0.DoesCustomizationSpecExist_Dec.__bases__ = tuple(bases) - - ns0.DoesCustomizationSpecExistRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DoesCustomizationSpecExist_Dec_Holder" - - class DoesCustomizationSpecExistResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DoesCustomizationSpecExistResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DoesCustomizationSpecExistResponse_Dec.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DoesCustomizationSpecExistResponse") - kw["aname"] = "_DoesCustomizationSpecExistResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DoesCustomizationSpecExistResponse_Holder" - self.pyclass = Holder - - class GetCustomizationSpec_Dec(ElementDeclaration): - literal = "GetCustomizationSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GetCustomizationSpec") - kw["aname"] = "_GetCustomizationSpec" - if ns0.GetCustomizationSpecRequestType_Def not in ns0.GetCustomizationSpec_Dec.__bases__: - bases = list(ns0.GetCustomizationSpec_Dec.__bases__) - bases.insert(0, ns0.GetCustomizationSpecRequestType_Def) - ns0.GetCustomizationSpec_Dec.__bases__ = tuple(bases) - - ns0.GetCustomizationSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GetCustomizationSpec_Dec_Holder" - - class GetCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GetCustomizationSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GetCustomizationSpecResponse_Dec.schema - TClist = [GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GetCustomizationSpecResponse") - kw["aname"] = "_GetCustomizationSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "GetCustomizationSpecResponse_Holder" - self.pyclass = Holder - - class CreateCustomizationSpec_Dec(ElementDeclaration): - literal = "CreateCustomizationSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateCustomizationSpec") - kw["aname"] = "_CreateCustomizationSpec" - if ns0.CreateCustomizationSpecRequestType_Def not in ns0.CreateCustomizationSpec_Dec.__bases__: - bases = list(ns0.CreateCustomizationSpec_Dec.__bases__) - bases.insert(0, ns0.CreateCustomizationSpecRequestType_Def) - ns0.CreateCustomizationSpec_Dec.__bases__ = tuple(bases) - - ns0.CreateCustomizationSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateCustomizationSpec_Dec_Holder" - - class CreateCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateCustomizationSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateCustomizationSpecResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CreateCustomizationSpecResponse") - kw["aname"] = "_CreateCustomizationSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CreateCustomizationSpecResponse_Holder" - self.pyclass = Holder - - class OverwriteCustomizationSpec_Dec(ElementDeclaration): - literal = "OverwriteCustomizationSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OverwriteCustomizationSpec") - kw["aname"] = "_OverwriteCustomizationSpec" - if ns0.OverwriteCustomizationSpecRequestType_Def not in ns0.OverwriteCustomizationSpec_Dec.__bases__: - bases = list(ns0.OverwriteCustomizationSpec_Dec.__bases__) - bases.insert(0, ns0.OverwriteCustomizationSpecRequestType_Def) - ns0.OverwriteCustomizationSpec_Dec.__bases__ = tuple(bases) - - ns0.OverwriteCustomizationSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OverwriteCustomizationSpec_Dec_Holder" - - class OverwriteCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "OverwriteCustomizationSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.OverwriteCustomizationSpecResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","OverwriteCustomizationSpecResponse") - kw["aname"] = "_OverwriteCustomizationSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "OverwriteCustomizationSpecResponse_Holder" - self.pyclass = Holder - - class DeleteCustomizationSpec_Dec(ElementDeclaration): - literal = "DeleteCustomizationSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeleteCustomizationSpec") - kw["aname"] = "_DeleteCustomizationSpec" - if ns0.DeleteCustomizationSpecRequestType_Def not in ns0.DeleteCustomizationSpec_Dec.__bases__: - bases = list(ns0.DeleteCustomizationSpec_Dec.__bases__) - bases.insert(0, ns0.DeleteCustomizationSpecRequestType_Def) - ns0.DeleteCustomizationSpec_Dec.__bases__ = tuple(bases) - - ns0.DeleteCustomizationSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeleteCustomizationSpec_Dec_Holder" - - class DeleteCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DeleteCustomizationSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DeleteCustomizationSpecResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DeleteCustomizationSpecResponse") - kw["aname"] = "_DeleteCustomizationSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DeleteCustomizationSpecResponse_Holder" - self.pyclass = Holder - - class DuplicateCustomizationSpec_Dec(ElementDeclaration): - literal = "DuplicateCustomizationSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DuplicateCustomizationSpec") - kw["aname"] = "_DuplicateCustomizationSpec" - if ns0.DuplicateCustomizationSpecRequestType_Def not in ns0.DuplicateCustomizationSpec_Dec.__bases__: - bases = list(ns0.DuplicateCustomizationSpec_Dec.__bases__) - bases.insert(0, ns0.DuplicateCustomizationSpecRequestType_Def) - ns0.DuplicateCustomizationSpec_Dec.__bases__ = tuple(bases) - - ns0.DuplicateCustomizationSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DuplicateCustomizationSpec_Dec_Holder" - - class DuplicateCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DuplicateCustomizationSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DuplicateCustomizationSpecResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DuplicateCustomizationSpecResponse") - kw["aname"] = "_DuplicateCustomizationSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DuplicateCustomizationSpecResponse_Holder" - self.pyclass = Holder - - class RenameCustomizationSpec_Dec(ElementDeclaration): - literal = "RenameCustomizationSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RenameCustomizationSpec") - kw["aname"] = "_RenameCustomizationSpec" - if ns0.RenameCustomizationSpecRequestType_Def not in ns0.RenameCustomizationSpec_Dec.__bases__: - bases = list(ns0.RenameCustomizationSpec_Dec.__bases__) - bases.insert(0, ns0.RenameCustomizationSpecRequestType_Def) - ns0.RenameCustomizationSpec_Dec.__bases__ = tuple(bases) - - ns0.RenameCustomizationSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RenameCustomizationSpec_Dec_Holder" - - class RenameCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RenameCustomizationSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RenameCustomizationSpecResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RenameCustomizationSpecResponse") - kw["aname"] = "_RenameCustomizationSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RenameCustomizationSpecResponse_Holder" - self.pyclass = Holder - - class CustomizationSpecItemToXml_Dec(ElementDeclaration): - literal = "CustomizationSpecItemToXml" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CustomizationSpecItemToXml") - kw["aname"] = "_CustomizationSpecItemToXml" - if ns0.CustomizationSpecItemToXmlRequestType_Def not in ns0.CustomizationSpecItemToXml_Dec.__bases__: - bases = list(ns0.CustomizationSpecItemToXml_Dec.__bases__) - bases.insert(0, ns0.CustomizationSpecItemToXmlRequestType_Def) - ns0.CustomizationSpecItemToXml_Dec.__bases__ = tuple(bases) - - ns0.CustomizationSpecItemToXmlRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CustomizationSpecItemToXml_Dec_Holder" - - class CustomizationSpecItemToXmlResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CustomizationSpecItemToXmlResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CustomizationSpecItemToXmlResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CustomizationSpecItemToXmlResponse") - kw["aname"] = "_CustomizationSpecItemToXmlResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CustomizationSpecItemToXmlResponse_Holder" - self.pyclass = Holder - - class XmlToCustomizationSpecItem_Dec(ElementDeclaration): - literal = "XmlToCustomizationSpecItem" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","XmlToCustomizationSpecItem") - kw["aname"] = "_XmlToCustomizationSpecItem" - if ns0.XmlToCustomizationSpecItemRequestType_Def not in ns0.XmlToCustomizationSpecItem_Dec.__bases__: - bases = list(ns0.XmlToCustomizationSpecItem_Dec.__bases__) - bases.insert(0, ns0.XmlToCustomizationSpecItemRequestType_Def) - ns0.XmlToCustomizationSpecItem_Dec.__bases__ = tuple(bases) - - ns0.XmlToCustomizationSpecItemRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "XmlToCustomizationSpecItem_Dec_Holder" - - class XmlToCustomizationSpecItemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "XmlToCustomizationSpecItemResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.XmlToCustomizationSpecItemResponse_Dec.schema - TClist = [GTD("urn:vim25","CustomizationSpecItem",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","XmlToCustomizationSpecItemResponse") - kw["aname"] = "_XmlToCustomizationSpecItemResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "XmlToCustomizationSpecItemResponse_Holder" - self.pyclass = Holder - - class CheckCustomizationResources_Dec(ElementDeclaration): - literal = "CheckCustomizationResources" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckCustomizationResources") - kw["aname"] = "_CheckCustomizationResources" - if ns0.CheckCustomizationResourcesRequestType_Def not in ns0.CheckCustomizationResources_Dec.__bases__: - bases = list(ns0.CheckCustomizationResources_Dec.__bases__) - bases.insert(0, ns0.CheckCustomizationResourcesRequestType_Def) - ns0.CheckCustomizationResources_Dec.__bases__ = tuple(bases) - - ns0.CheckCustomizationResourcesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckCustomizationResources_Dec_Holder" - - class CheckCustomizationResourcesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckCustomizationResourcesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckCustomizationResourcesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CheckCustomizationResourcesResponse") - kw["aname"] = "_CheckCustomizationResourcesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CheckCustomizationResourcesResponse_Holder" - self.pyclass = Holder - - class QueryConnectionInfo_Dec(ElementDeclaration): - literal = "QueryConnectionInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryConnectionInfo") - kw["aname"] = "_QueryConnectionInfo" - if ns0.QueryConnectionInfoRequestType_Def not in ns0.QueryConnectionInfo_Dec.__bases__: - bases = list(ns0.QueryConnectionInfo_Dec.__bases__) - bases.insert(0, ns0.QueryConnectionInfoRequestType_Def) - ns0.QueryConnectionInfo_Dec.__bases__ = tuple(bases) - - ns0.QueryConnectionInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryConnectionInfo_Dec_Holder" - - class QueryConnectionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryConnectionInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryConnectionInfoResponse_Dec.schema - TClist = [GTD("urn:vim25","HostConnectInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryConnectionInfoResponse") - kw["aname"] = "_QueryConnectionInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryConnectionInfoResponse_Holder" - self.pyclass = Holder - - class PowerOnMultiVM_Dec(ElementDeclaration): - literal = "PowerOnMultiVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnMultiVM") - kw["aname"] = "_PowerOnMultiVM" - if ns0.PowerOnMultiVMRequestType_Def not in ns0.PowerOnMultiVM_Dec.__bases__: - bases = list(ns0.PowerOnMultiVM_Dec.__bases__) - bases.insert(0, ns0.PowerOnMultiVMRequestType_Def) - ns0.PowerOnMultiVM_Dec.__bases__ = tuple(bases) - - ns0.PowerOnMultiVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnMultiVM_Dec_Holder" - - class PowerOnMultiVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOnMultiVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOnMultiVMResponse_Dec.schema - TClist = [GTD("urn:vim25","ClusterPowerOnVmResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerOnMultiVMResponse") - kw["aname"] = "_PowerOnMultiVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerOnMultiVMResponse_Holder" - self.pyclass = Holder - - class PowerOnMultiVM_Task_Dec(ElementDeclaration): - literal = "PowerOnMultiVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnMultiVM_Task") - kw["aname"] = "_PowerOnMultiVM_Task" - if ns0.PowerOnMultiVMRequestType_Def not in ns0.PowerOnMultiVM_Task_Dec.__bases__: - bases = list(ns0.PowerOnMultiVM_Task_Dec.__bases__) - bases.insert(0, ns0.PowerOnMultiVMRequestType_Def) - ns0.PowerOnMultiVM_Task_Dec.__bases__ = tuple(bases) - - ns0.PowerOnMultiVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnMultiVM_Task_Dec_Holder" - - class PowerOnMultiVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOnMultiVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOnMultiVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerOnMultiVM_TaskResponse") - kw["aname"] = "_PowerOnMultiVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerOnMultiVM_TaskResponse_Holder" - self.pyclass = Holder - - class RefreshDatastore_Dec(ElementDeclaration): - literal = "RefreshDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshDatastore") - kw["aname"] = "_RefreshDatastore" - if ns0.RefreshDatastoreRequestType_Def not in ns0.RefreshDatastore_Dec.__bases__: - bases = list(ns0.RefreshDatastore_Dec.__bases__) - bases.insert(0, ns0.RefreshDatastoreRequestType_Def) - ns0.RefreshDatastore_Dec.__bases__ = tuple(bases) - - ns0.RefreshDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshDatastore_Dec_Holder" - - class RefreshDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshDatastoreResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshDatastoreResponse") - kw["aname"] = "_RefreshDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshDatastoreResponse_Holder" - self.pyclass = Holder - - class RefreshDatastoreStorageInfo_Dec(ElementDeclaration): - literal = "RefreshDatastoreStorageInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshDatastoreStorageInfo") - kw["aname"] = "_RefreshDatastoreStorageInfo" - if ns0.RefreshDatastoreStorageInfoRequestType_Def not in ns0.RefreshDatastoreStorageInfo_Dec.__bases__: - bases = list(ns0.RefreshDatastoreStorageInfo_Dec.__bases__) - bases.insert(0, ns0.RefreshDatastoreStorageInfoRequestType_Def) - ns0.RefreshDatastoreStorageInfo_Dec.__bases__ = tuple(bases) - - ns0.RefreshDatastoreStorageInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshDatastoreStorageInfo_Dec_Holder" - - class RefreshDatastoreStorageInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshDatastoreStorageInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshDatastoreStorageInfoResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshDatastoreStorageInfoResponse") - kw["aname"] = "_RefreshDatastoreStorageInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshDatastoreStorageInfoResponse_Holder" - self.pyclass = Holder - - class RenameDatastore_Dec(ElementDeclaration): - literal = "RenameDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RenameDatastore") - kw["aname"] = "_RenameDatastore" - if ns0.RenameDatastoreRequestType_Def not in ns0.RenameDatastore_Dec.__bases__: - bases = list(ns0.RenameDatastore_Dec.__bases__) - bases.insert(0, ns0.RenameDatastoreRequestType_Def) - ns0.RenameDatastore_Dec.__bases__ = tuple(bases) - - ns0.RenameDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RenameDatastore_Dec_Holder" - - class RenameDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RenameDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RenameDatastoreResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RenameDatastoreResponse") - kw["aname"] = "_RenameDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RenameDatastoreResponse_Holder" - self.pyclass = Holder - - class DestroyDatastore_Dec(ElementDeclaration): - literal = "DestroyDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestroyDatastore") - kw["aname"] = "_DestroyDatastore" - if ns0.DestroyDatastoreRequestType_Def not in ns0.DestroyDatastore_Dec.__bases__: - bases = list(ns0.DestroyDatastore_Dec.__bases__) - bases.insert(0, ns0.DestroyDatastoreRequestType_Def) - ns0.DestroyDatastore_Dec.__bases__ = tuple(bases) - - ns0.DestroyDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestroyDatastore_Dec_Holder" - - class DestroyDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyDatastoreResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyDatastoreResponse") - kw["aname"] = "_DestroyDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyDatastoreResponse_Holder" - self.pyclass = Holder - - class QueryDescriptions_Dec(ElementDeclaration): - literal = "QueryDescriptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryDescriptions") - kw["aname"] = "_QueryDescriptions" - if ns0.QueryDescriptionsRequestType_Def not in ns0.QueryDescriptions_Dec.__bases__: - bases = list(ns0.QueryDescriptions_Dec.__bases__) - bases.insert(0, ns0.QueryDescriptionsRequestType_Def) - ns0.QueryDescriptions_Dec.__bases__ = tuple(bases) - - ns0.QueryDescriptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryDescriptions_Dec_Holder" - - class QueryDescriptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryDescriptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryDescriptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","DiagnosticManagerLogDescriptor",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryDescriptionsResponse") - kw["aname"] = "_QueryDescriptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryDescriptionsResponse_Holder" - self.pyclass = Holder - - class BrowseDiagnosticLog_Dec(ElementDeclaration): - literal = "BrowseDiagnosticLog" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","BrowseDiagnosticLog") - kw["aname"] = "_BrowseDiagnosticLog" - if ns0.BrowseDiagnosticLogRequestType_Def not in ns0.BrowseDiagnosticLog_Dec.__bases__: - bases = list(ns0.BrowseDiagnosticLog_Dec.__bases__) - bases.insert(0, ns0.BrowseDiagnosticLogRequestType_Def) - ns0.BrowseDiagnosticLog_Dec.__bases__ = tuple(bases) - - ns0.BrowseDiagnosticLogRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "BrowseDiagnosticLog_Dec_Holder" - - class BrowseDiagnosticLogResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "BrowseDiagnosticLogResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.BrowseDiagnosticLogResponse_Dec.schema - TClist = [GTD("urn:vim25","DiagnosticManagerLogHeader",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","BrowseDiagnosticLogResponse") - kw["aname"] = "_BrowseDiagnosticLogResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "BrowseDiagnosticLogResponse_Holder" - self.pyclass = Holder - - class GenerateLogBundles_Dec(ElementDeclaration): - literal = "GenerateLogBundles" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GenerateLogBundles") - kw["aname"] = "_GenerateLogBundles" - if ns0.GenerateLogBundlesRequestType_Def not in ns0.GenerateLogBundles_Dec.__bases__: - bases = list(ns0.GenerateLogBundles_Dec.__bases__) - bases.insert(0, ns0.GenerateLogBundlesRequestType_Def) - ns0.GenerateLogBundles_Dec.__bases__ = tuple(bases) - - ns0.GenerateLogBundlesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GenerateLogBundles_Dec_Holder" - - class GenerateLogBundlesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GenerateLogBundlesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GenerateLogBundlesResponse_Dec.schema - TClist = [GTD("urn:vim25","DiagnosticManagerBundleInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GenerateLogBundlesResponse") - kw["aname"] = "_GenerateLogBundlesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "GenerateLogBundlesResponse_Holder" - self.pyclass = Holder - - class GenerateLogBundles_Task_Dec(ElementDeclaration): - literal = "GenerateLogBundles_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GenerateLogBundles_Task") - kw["aname"] = "_GenerateLogBundles_Task" - if ns0.GenerateLogBundlesRequestType_Def not in ns0.GenerateLogBundles_Task_Dec.__bases__: - bases = list(ns0.GenerateLogBundles_Task_Dec.__bases__) - bases.insert(0, ns0.GenerateLogBundlesRequestType_Def) - ns0.GenerateLogBundles_Task_Dec.__bases__ = tuple(bases) - - ns0.GenerateLogBundlesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GenerateLogBundles_Task_Dec_Holder" - - class GenerateLogBundles_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GenerateLogBundles_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GenerateLogBundles_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GenerateLogBundles_TaskResponse") - kw["aname"] = "_GenerateLogBundles_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "GenerateLogBundles_TaskResponse_Holder" - self.pyclass = Holder - - class DVSFetchKeyOfPorts_Dec(ElementDeclaration): - literal = "DVSFetchKeyOfPorts" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSFetchKeyOfPorts") - kw["aname"] = "_DVSFetchKeyOfPorts" - if ns0.DVSFetchKeyOfPortsRequestType_Def not in ns0.DVSFetchKeyOfPorts_Dec.__bases__: - bases = list(ns0.DVSFetchKeyOfPorts_Dec.__bases__) - bases.insert(0, ns0.DVSFetchKeyOfPortsRequestType_Def) - ns0.DVSFetchKeyOfPorts_Dec.__bases__ = tuple(bases) - - ns0.DVSFetchKeyOfPortsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSFetchKeyOfPorts_Dec_Holder" - - class DVSFetchKeyOfPortsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSFetchKeyOfPortsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSFetchKeyOfPortsResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSFetchKeyOfPortsResponse") - kw["aname"] = "_DVSFetchKeyOfPortsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "DVSFetchKeyOfPortsResponse_Holder" - self.pyclass = Holder - - class DVSFetchPorts_Dec(ElementDeclaration): - literal = "DVSFetchPorts" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSFetchPorts") - kw["aname"] = "_DVSFetchPorts" - if ns0.DVSFetchPortsRequestType_Def not in ns0.DVSFetchPorts_Dec.__bases__: - bases = list(ns0.DVSFetchPorts_Dec.__bases__) - bases.insert(0, ns0.DVSFetchPortsRequestType_Def) - ns0.DVSFetchPorts_Dec.__bases__ = tuple(bases) - - ns0.DVSFetchPortsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSFetchPorts_Dec_Holder" - - class DVSFetchPortsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSFetchPortsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSFetchPortsResponse_Dec.schema - TClist = [GTD("urn:vim25","DistributedVirtualPort",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSFetchPortsResponse") - kw["aname"] = "_DVSFetchPortsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "DVSFetchPortsResponse_Holder" - self.pyclass = Holder - - class DVSQueryUsedVlanId_Dec(ElementDeclaration): - literal = "DVSQueryUsedVlanId" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSQueryUsedVlanId") - kw["aname"] = "_DVSQueryUsedVlanId" - if ns0.DVSQueryUsedVlanIdRequestType_Def not in ns0.DVSQueryUsedVlanId_Dec.__bases__: - bases = list(ns0.DVSQueryUsedVlanId_Dec.__bases__) - bases.insert(0, ns0.DVSQueryUsedVlanIdRequestType_Def) - ns0.DVSQueryUsedVlanId_Dec.__bases__ = tuple(bases) - - ns0.DVSQueryUsedVlanIdRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSQueryUsedVlanId_Dec_Holder" - - class DVSQueryUsedVlanIdResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSQueryUsedVlanIdResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSQueryUsedVlanIdResponse_Dec.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSQueryUsedVlanIdResponse") - kw["aname"] = "_DVSQueryUsedVlanIdResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "DVSQueryUsedVlanIdResponse_Holder" - self.pyclass = Holder - - class DVSReconfigure_Dec(ElementDeclaration): - literal = "DVSReconfigure" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSReconfigure") - kw["aname"] = "_DVSReconfigure" - if ns0.DVSReconfigureRequestType_Def not in ns0.DVSReconfigure_Dec.__bases__: - bases = list(ns0.DVSReconfigure_Dec.__bases__) - bases.insert(0, ns0.DVSReconfigureRequestType_Def) - ns0.DVSReconfigure_Dec.__bases__ = tuple(bases) - - ns0.DVSReconfigureRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSReconfigure_Dec_Holder" - - class DVSReconfigureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSReconfigureResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSReconfigureResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSReconfigureResponse") - kw["aname"] = "_DVSReconfigureResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSReconfigureResponse_Holder" - self.pyclass = Holder - - class DVSReconfigure_Task_Dec(ElementDeclaration): - literal = "DVSReconfigure_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSReconfigure_Task") - kw["aname"] = "_DVSReconfigure_Task" - if ns0.DVSReconfigureRequestType_Def not in ns0.DVSReconfigure_Task_Dec.__bases__: - bases = list(ns0.DVSReconfigure_Task_Dec.__bases__) - bases.insert(0, ns0.DVSReconfigureRequestType_Def) - ns0.DVSReconfigure_Task_Dec.__bases__ = tuple(bases) - - ns0.DVSReconfigureRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSReconfigure_Task_Dec_Holder" - - class DVSReconfigure_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSReconfigure_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSReconfigure_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSReconfigure_TaskResponse") - kw["aname"] = "_DVSReconfigure_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DVSReconfigure_TaskResponse_Holder" - self.pyclass = Holder - - class DVSPerformProductSpecOperation_Dec(ElementDeclaration): - literal = "DVSPerformProductSpecOperation" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperation") - kw["aname"] = "_DVSPerformProductSpecOperation" - if ns0.DVSPerformProductSpecOperationRequestType_Def not in ns0.DVSPerformProductSpecOperation_Dec.__bases__: - bases = list(ns0.DVSPerformProductSpecOperation_Dec.__bases__) - bases.insert(0, ns0.DVSPerformProductSpecOperationRequestType_Def) - ns0.DVSPerformProductSpecOperation_Dec.__bases__ = tuple(bases) - - ns0.DVSPerformProductSpecOperationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSPerformProductSpecOperation_Dec_Holder" - - class DVSPerformProductSpecOperationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSPerformProductSpecOperationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSPerformProductSpecOperationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperationResponse") - kw["aname"] = "_DVSPerformProductSpecOperationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSPerformProductSpecOperationResponse_Holder" - self.pyclass = Holder - - class DVSPerformProductSpecOperation_Task_Dec(ElementDeclaration): - literal = "DVSPerformProductSpecOperation_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperation_Task") - kw["aname"] = "_DVSPerformProductSpecOperation_Task" - if ns0.DVSPerformProductSpecOperationRequestType_Def not in ns0.DVSPerformProductSpecOperation_Task_Dec.__bases__: - bases = list(ns0.DVSPerformProductSpecOperation_Task_Dec.__bases__) - bases.insert(0, ns0.DVSPerformProductSpecOperationRequestType_Def) - ns0.DVSPerformProductSpecOperation_Task_Dec.__bases__ = tuple(bases) - - ns0.DVSPerformProductSpecOperationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSPerformProductSpecOperation_Task_Dec_Holder" - - class DVSPerformProductSpecOperation_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSPerformProductSpecOperation_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSPerformProductSpecOperation_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSPerformProductSpecOperation_TaskResponse") - kw["aname"] = "_DVSPerformProductSpecOperation_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DVSPerformProductSpecOperation_TaskResponse_Holder" - self.pyclass = Holder - - class DVSMerge_Dec(ElementDeclaration): - literal = "DVSMerge" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSMerge") - kw["aname"] = "_DVSMerge" - if ns0.DVSMergeRequestType_Def not in ns0.DVSMerge_Dec.__bases__: - bases = list(ns0.DVSMerge_Dec.__bases__) - bases.insert(0, ns0.DVSMergeRequestType_Def) - ns0.DVSMerge_Dec.__bases__ = tuple(bases) - - ns0.DVSMergeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSMerge_Dec_Holder" - - class DVSMergeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSMergeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSMergeResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSMergeResponse") - kw["aname"] = "_DVSMergeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSMergeResponse_Holder" - self.pyclass = Holder - - class DVSMerge_Task_Dec(ElementDeclaration): - literal = "DVSMerge_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSMerge_Task") - kw["aname"] = "_DVSMerge_Task" - if ns0.DVSMergeRequestType_Def not in ns0.DVSMerge_Task_Dec.__bases__: - bases = list(ns0.DVSMerge_Task_Dec.__bases__) - bases.insert(0, ns0.DVSMergeRequestType_Def) - ns0.DVSMerge_Task_Dec.__bases__ = tuple(bases) - - ns0.DVSMergeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSMerge_Task_Dec_Holder" - - class DVSMerge_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSMerge_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSMerge_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSMerge_TaskResponse") - kw["aname"] = "_DVSMerge_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DVSMerge_TaskResponse_Holder" - self.pyclass = Holder - - class DVSAddPortgroups_Dec(ElementDeclaration): - literal = "DVSAddPortgroups" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSAddPortgroups") - kw["aname"] = "_DVSAddPortgroups" - if ns0.DVSAddPortgroupsRequestType_Def not in ns0.DVSAddPortgroups_Dec.__bases__: - bases = list(ns0.DVSAddPortgroups_Dec.__bases__) - bases.insert(0, ns0.DVSAddPortgroupsRequestType_Def) - ns0.DVSAddPortgroups_Dec.__bases__ = tuple(bases) - - ns0.DVSAddPortgroupsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSAddPortgroups_Dec_Holder" - - class DVSAddPortgroupsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSAddPortgroupsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSAddPortgroupsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSAddPortgroupsResponse") - kw["aname"] = "_DVSAddPortgroupsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSAddPortgroupsResponse_Holder" - self.pyclass = Holder - - class DVSMovePort_Dec(ElementDeclaration): - literal = "DVSMovePort" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSMovePort") - kw["aname"] = "_DVSMovePort" - if ns0.DVSMovePortRequestType_Def not in ns0.DVSMovePort_Dec.__bases__: - bases = list(ns0.DVSMovePort_Dec.__bases__) - bases.insert(0, ns0.DVSMovePortRequestType_Def) - ns0.DVSMovePort_Dec.__bases__ = tuple(bases) - - ns0.DVSMovePortRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSMovePort_Dec_Holder" - - class DVSMovePortResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSMovePortResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSMovePortResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSMovePortResponse") - kw["aname"] = "_DVSMovePortResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSMovePortResponse_Holder" - self.pyclass = Holder - - class DVSUpdateCapability_Dec(ElementDeclaration): - literal = "DVSUpdateCapability" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSUpdateCapability") - kw["aname"] = "_DVSUpdateCapability" - if ns0.DVSUpdateCapabilityRequestType_Def not in ns0.DVSUpdateCapability_Dec.__bases__: - bases = list(ns0.DVSUpdateCapability_Dec.__bases__) - bases.insert(0, ns0.DVSUpdateCapabilityRequestType_Def) - ns0.DVSUpdateCapability_Dec.__bases__ = tuple(bases) - - ns0.DVSUpdateCapabilityRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSUpdateCapability_Dec_Holder" - - class DVSUpdateCapabilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSUpdateCapabilityResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSUpdateCapabilityResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSUpdateCapabilityResponse") - kw["aname"] = "_DVSUpdateCapabilityResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSUpdateCapabilityResponse_Holder" - self.pyclass = Holder - - class ReconfigurePort_Dec(ElementDeclaration): - literal = "ReconfigurePort" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigurePort") - kw["aname"] = "_ReconfigurePort" - if ns0.ReconfigurePortRequestType_Def not in ns0.ReconfigurePort_Dec.__bases__: - bases = list(ns0.ReconfigurePort_Dec.__bases__) - bases.insert(0, ns0.ReconfigurePortRequestType_Def) - ns0.ReconfigurePort_Dec.__bases__ = tuple(bases) - - ns0.ReconfigurePortRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigurePort_Dec_Holder" - - class ReconfigurePortResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigurePortResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigurePortResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigurePortResponse") - kw["aname"] = "_ReconfigurePortResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigurePortResponse_Holder" - self.pyclass = Holder - - class DVSRefreshPortState_Dec(ElementDeclaration): - literal = "DVSRefreshPortState" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSRefreshPortState") - kw["aname"] = "_DVSRefreshPortState" - if ns0.DVSRefreshPortStateRequestType_Def not in ns0.DVSRefreshPortState_Dec.__bases__: - bases = list(ns0.DVSRefreshPortState_Dec.__bases__) - bases.insert(0, ns0.DVSRefreshPortStateRequestType_Def) - ns0.DVSRefreshPortState_Dec.__bases__ = tuple(bases) - - ns0.DVSRefreshPortStateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSRefreshPortState_Dec_Holder" - - class DVSRefreshPortStateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSRefreshPortStateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSRefreshPortStateResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSRefreshPortStateResponse") - kw["aname"] = "_DVSRefreshPortStateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSRefreshPortStateResponse_Holder" - self.pyclass = Holder - - class DVSRectifyHost_Dec(ElementDeclaration): - literal = "DVSRectifyHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSRectifyHost") - kw["aname"] = "_DVSRectifyHost" - if ns0.DVSRectifyHostRequestType_Def not in ns0.DVSRectifyHost_Dec.__bases__: - bases = list(ns0.DVSRectifyHost_Dec.__bases__) - bases.insert(0, ns0.DVSRectifyHostRequestType_Def) - ns0.DVSRectifyHost_Dec.__bases__ = tuple(bases) - - ns0.DVSRectifyHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSRectifyHost_Dec_Holder" - - class DVSRectifyHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSRectifyHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSRectifyHostResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVSRectifyHostResponse") - kw["aname"] = "_DVSRectifyHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVSRectifyHostResponse_Holder" - self.pyclass = Holder - - class QueryConfigOptionDescriptor_Dec(ElementDeclaration): - literal = "QueryConfigOptionDescriptor" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryConfigOptionDescriptor") - kw["aname"] = "_QueryConfigOptionDescriptor" - if ns0.QueryConfigOptionDescriptorRequestType_Def not in ns0.QueryConfigOptionDescriptor_Dec.__bases__: - bases = list(ns0.QueryConfigOptionDescriptor_Dec.__bases__) - bases.insert(0, ns0.QueryConfigOptionDescriptorRequestType_Def) - ns0.QueryConfigOptionDescriptor_Dec.__bases__ = tuple(bases) - - ns0.QueryConfigOptionDescriptorRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryConfigOptionDescriptor_Dec_Holder" - - class QueryConfigOptionDescriptorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryConfigOptionDescriptorResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryConfigOptionDescriptorResponse_Dec.schema - TClist = [GTD("urn:vim25","VirtualMachineConfigOptionDescriptor",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryConfigOptionDescriptorResponse") - kw["aname"] = "_QueryConfigOptionDescriptorResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryConfigOptionDescriptorResponse_Holder" - self.pyclass = Holder - - class QueryConfigOption_Dec(ElementDeclaration): - literal = "QueryConfigOption" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryConfigOption") - kw["aname"] = "_QueryConfigOption" - if ns0.QueryConfigOptionRequestType_Def not in ns0.QueryConfigOption_Dec.__bases__: - bases = list(ns0.QueryConfigOption_Dec.__bases__) - bases.insert(0, ns0.QueryConfigOptionRequestType_Def) - ns0.QueryConfigOption_Dec.__bases__ = tuple(bases) - - ns0.QueryConfigOptionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryConfigOption_Dec_Holder" - - class QueryConfigOptionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryConfigOptionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryConfigOptionResponse_Dec.schema - TClist = [GTD("urn:vim25","VirtualMachineConfigOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryConfigOptionResponse") - kw["aname"] = "_QueryConfigOptionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryConfigOptionResponse_Holder" - self.pyclass = Holder - - class QueryConfigTarget_Dec(ElementDeclaration): - literal = "QueryConfigTarget" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryConfigTarget") - kw["aname"] = "_QueryConfigTarget" - if ns0.QueryConfigTargetRequestType_Def not in ns0.QueryConfigTarget_Dec.__bases__: - bases = list(ns0.QueryConfigTarget_Dec.__bases__) - bases.insert(0, ns0.QueryConfigTargetRequestType_Def) - ns0.QueryConfigTarget_Dec.__bases__ = tuple(bases) - - ns0.QueryConfigTargetRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryConfigTarget_Dec_Holder" - - class QueryConfigTargetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryConfigTargetResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryConfigTargetResponse_Dec.schema - TClist = [GTD("urn:vim25","ConfigTarget",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryConfigTargetResponse") - kw["aname"] = "_QueryConfigTargetResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryConfigTargetResponse_Holder" - self.pyclass = Holder - - class QueryTargetCapabilities_Dec(ElementDeclaration): - literal = "QueryTargetCapabilities" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryTargetCapabilities") - kw["aname"] = "_QueryTargetCapabilities" - if ns0.QueryTargetCapabilitiesRequestType_Def not in ns0.QueryTargetCapabilities_Dec.__bases__: - bases = list(ns0.QueryTargetCapabilities_Dec.__bases__) - bases.insert(0, ns0.QueryTargetCapabilitiesRequestType_Def) - ns0.QueryTargetCapabilities_Dec.__bases__ = tuple(bases) - - ns0.QueryTargetCapabilitiesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryTargetCapabilities_Dec_Holder" - - class QueryTargetCapabilitiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryTargetCapabilitiesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryTargetCapabilitiesResponse_Dec.schema - TClist = [GTD("urn:vim25","HostCapability",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryTargetCapabilitiesResponse") - kw["aname"] = "_QueryTargetCapabilitiesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryTargetCapabilitiesResponse_Holder" - self.pyclass = Holder - - class setCustomValue_Dec(ElementDeclaration): - literal = "setCustomValue" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","setCustomValue") - kw["aname"] = "_setCustomValue" - if ns0.setCustomValueRequestType_Def not in ns0.setCustomValue_Dec.__bases__: - bases = list(ns0.setCustomValue_Dec.__bases__) - bases.insert(0, ns0.setCustomValueRequestType_Def) - ns0.setCustomValue_Dec.__bases__ = tuple(bases) - - ns0.setCustomValueRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "setCustomValue_Dec_Holder" - - class setCustomValueResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "setCustomValueResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.setCustomValueResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","setCustomValueResponse") - kw["aname"] = "_setCustomValueResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "setCustomValueResponse_Holder" - self.pyclass = Holder - - class UnregisterExtension_Dec(ElementDeclaration): - literal = "UnregisterExtension" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnregisterExtension") - kw["aname"] = "_UnregisterExtension" - if ns0.UnregisterExtensionRequestType_Def not in ns0.UnregisterExtension_Dec.__bases__: - bases = list(ns0.UnregisterExtension_Dec.__bases__) - bases.insert(0, ns0.UnregisterExtensionRequestType_Def) - ns0.UnregisterExtension_Dec.__bases__ = tuple(bases) - - ns0.UnregisterExtensionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnregisterExtension_Dec_Holder" - - class UnregisterExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UnregisterExtensionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UnregisterExtensionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UnregisterExtensionResponse") - kw["aname"] = "_UnregisterExtensionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UnregisterExtensionResponse_Holder" - self.pyclass = Holder - - class FindExtension_Dec(ElementDeclaration): - literal = "FindExtension" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindExtension") - kw["aname"] = "_FindExtension" - if ns0.FindExtensionRequestType_Def not in ns0.FindExtension_Dec.__bases__: - bases = list(ns0.FindExtension_Dec.__bases__) - bases.insert(0, ns0.FindExtensionRequestType_Def) - ns0.FindExtension_Dec.__bases__ = tuple(bases) - - ns0.FindExtensionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindExtension_Dec_Holder" - - class FindExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindExtensionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindExtensionResponse_Dec.schema - TClist = [GTD("urn:vim25","Extension",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindExtensionResponse") - kw["aname"] = "_FindExtensionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FindExtensionResponse_Holder" - self.pyclass = Holder - - class RegisterExtension_Dec(ElementDeclaration): - literal = "RegisterExtension" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RegisterExtension") - kw["aname"] = "_RegisterExtension" - if ns0.RegisterExtensionRequestType_Def not in ns0.RegisterExtension_Dec.__bases__: - bases = list(ns0.RegisterExtension_Dec.__bases__) - bases.insert(0, ns0.RegisterExtensionRequestType_Def) - ns0.RegisterExtension_Dec.__bases__ = tuple(bases) - - ns0.RegisterExtensionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RegisterExtension_Dec_Holder" - - class RegisterExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RegisterExtensionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RegisterExtensionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RegisterExtensionResponse") - kw["aname"] = "_RegisterExtensionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RegisterExtensionResponse_Holder" - self.pyclass = Holder - - class UpdateExtension_Dec(ElementDeclaration): - literal = "UpdateExtension" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateExtension") - kw["aname"] = "_UpdateExtension" - if ns0.UpdateExtensionRequestType_Def not in ns0.UpdateExtension_Dec.__bases__: - bases = list(ns0.UpdateExtension_Dec.__bases__) - bases.insert(0, ns0.UpdateExtensionRequestType_Def) - ns0.UpdateExtension_Dec.__bases__ = tuple(bases) - - ns0.UpdateExtensionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateExtension_Dec_Holder" - - class UpdateExtensionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateExtensionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateExtensionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateExtensionResponse") - kw["aname"] = "_UpdateExtensionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateExtensionResponse_Holder" - self.pyclass = Holder - - class GetPublicKey_Dec(ElementDeclaration): - literal = "GetPublicKey" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GetPublicKey") - kw["aname"] = "_GetPublicKey" - if ns0.GetPublicKeyRequestType_Def not in ns0.GetPublicKey_Dec.__bases__: - bases = list(ns0.GetPublicKey_Dec.__bases__) - bases.insert(0, ns0.GetPublicKeyRequestType_Def) - ns0.GetPublicKey_Dec.__bases__ = tuple(bases) - - ns0.GetPublicKeyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GetPublicKey_Dec_Holder" - - class GetPublicKeyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GetPublicKeyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GetPublicKeyResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GetPublicKeyResponse") - kw["aname"] = "_GetPublicKeyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "GetPublicKeyResponse_Holder" - self.pyclass = Holder - - class SetPublicKey_Dec(ElementDeclaration): - literal = "SetPublicKey" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetPublicKey") - kw["aname"] = "_SetPublicKey" - if ns0.SetPublicKeyRequestType_Def not in ns0.SetPublicKey_Dec.__bases__: - bases = list(ns0.SetPublicKey_Dec.__bases__) - bases.insert(0, ns0.SetPublicKeyRequestType_Def) - ns0.SetPublicKey_Dec.__bases__ = tuple(bases) - - ns0.SetPublicKeyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetPublicKey_Dec_Holder" - - class SetPublicKeyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetPublicKeyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetPublicKeyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetPublicKeyResponse") - kw["aname"] = "_SetPublicKeyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetPublicKeyResponse_Holder" - self.pyclass = Holder - - class MoveDatastoreFile_Dec(ElementDeclaration): - literal = "MoveDatastoreFile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveDatastoreFile") - kw["aname"] = "_MoveDatastoreFile" - if ns0.MoveDatastoreFileRequestType_Def not in ns0.MoveDatastoreFile_Dec.__bases__: - bases = list(ns0.MoveDatastoreFile_Dec.__bases__) - bases.insert(0, ns0.MoveDatastoreFileRequestType_Def) - ns0.MoveDatastoreFile_Dec.__bases__ = tuple(bases) - - ns0.MoveDatastoreFileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveDatastoreFile_Dec_Holder" - - class MoveDatastoreFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveDatastoreFileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveDatastoreFileResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MoveDatastoreFileResponse") - kw["aname"] = "_MoveDatastoreFileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MoveDatastoreFileResponse_Holder" - self.pyclass = Holder - - class MoveDatastoreFile_Task_Dec(ElementDeclaration): - literal = "MoveDatastoreFile_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveDatastoreFile_Task") - kw["aname"] = "_MoveDatastoreFile_Task" - if ns0.MoveDatastoreFileRequestType_Def not in ns0.MoveDatastoreFile_Task_Dec.__bases__: - bases = list(ns0.MoveDatastoreFile_Task_Dec.__bases__) - bases.insert(0, ns0.MoveDatastoreFileRequestType_Def) - ns0.MoveDatastoreFile_Task_Dec.__bases__ = tuple(bases) - - ns0.MoveDatastoreFileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveDatastoreFile_Task_Dec_Holder" - - class MoveDatastoreFile_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveDatastoreFile_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveDatastoreFile_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MoveDatastoreFile_TaskResponse") - kw["aname"] = "_MoveDatastoreFile_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MoveDatastoreFile_TaskResponse_Holder" - self.pyclass = Holder - - class CopyDatastoreFile_Dec(ElementDeclaration): - literal = "CopyDatastoreFile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CopyDatastoreFile") - kw["aname"] = "_CopyDatastoreFile" - if ns0.CopyDatastoreFileRequestType_Def not in ns0.CopyDatastoreFile_Dec.__bases__: - bases = list(ns0.CopyDatastoreFile_Dec.__bases__) - bases.insert(0, ns0.CopyDatastoreFileRequestType_Def) - ns0.CopyDatastoreFile_Dec.__bases__ = tuple(bases) - - ns0.CopyDatastoreFileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CopyDatastoreFile_Dec_Holder" - - class CopyDatastoreFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CopyDatastoreFileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CopyDatastoreFileResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CopyDatastoreFileResponse") - kw["aname"] = "_CopyDatastoreFileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CopyDatastoreFileResponse_Holder" - self.pyclass = Holder - - class CopyDatastoreFile_Task_Dec(ElementDeclaration): - literal = "CopyDatastoreFile_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CopyDatastoreFile_Task") - kw["aname"] = "_CopyDatastoreFile_Task" - if ns0.CopyDatastoreFileRequestType_Def not in ns0.CopyDatastoreFile_Task_Dec.__bases__: - bases = list(ns0.CopyDatastoreFile_Task_Dec.__bases__) - bases.insert(0, ns0.CopyDatastoreFileRequestType_Def) - ns0.CopyDatastoreFile_Task_Dec.__bases__ = tuple(bases) - - ns0.CopyDatastoreFileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CopyDatastoreFile_Task_Dec_Holder" - - class CopyDatastoreFile_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CopyDatastoreFile_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CopyDatastoreFile_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CopyDatastoreFile_TaskResponse") - kw["aname"] = "_CopyDatastoreFile_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CopyDatastoreFile_TaskResponse_Holder" - self.pyclass = Holder - - class DeleteDatastoreFile_Dec(ElementDeclaration): - literal = "DeleteDatastoreFile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeleteDatastoreFile") - kw["aname"] = "_DeleteDatastoreFile" - if ns0.DeleteDatastoreFileRequestType_Def not in ns0.DeleteDatastoreFile_Dec.__bases__: - bases = list(ns0.DeleteDatastoreFile_Dec.__bases__) - bases.insert(0, ns0.DeleteDatastoreFileRequestType_Def) - ns0.DeleteDatastoreFile_Dec.__bases__ = tuple(bases) - - ns0.DeleteDatastoreFileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeleteDatastoreFile_Dec_Holder" - - class DeleteDatastoreFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DeleteDatastoreFileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DeleteDatastoreFileResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DeleteDatastoreFileResponse") - kw["aname"] = "_DeleteDatastoreFileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DeleteDatastoreFileResponse_Holder" - self.pyclass = Holder - - class DeleteDatastoreFile_Task_Dec(ElementDeclaration): - literal = "DeleteDatastoreFile_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeleteDatastoreFile_Task") - kw["aname"] = "_DeleteDatastoreFile_Task" - if ns0.DeleteDatastoreFileRequestType_Def not in ns0.DeleteDatastoreFile_Task_Dec.__bases__: - bases = list(ns0.DeleteDatastoreFile_Task_Dec.__bases__) - bases.insert(0, ns0.DeleteDatastoreFileRequestType_Def) - ns0.DeleteDatastoreFile_Task_Dec.__bases__ = tuple(bases) - - ns0.DeleteDatastoreFileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeleteDatastoreFile_Task_Dec_Holder" - - class DeleteDatastoreFile_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DeleteDatastoreFile_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DeleteDatastoreFile_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DeleteDatastoreFile_TaskResponse") - kw["aname"] = "_DeleteDatastoreFile_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DeleteDatastoreFile_TaskResponse_Holder" - self.pyclass = Holder - - class MakeDirectory_Dec(ElementDeclaration): - literal = "MakeDirectory" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MakeDirectory") - kw["aname"] = "_MakeDirectory" - if ns0.MakeDirectoryRequestType_Def not in ns0.MakeDirectory_Dec.__bases__: - bases = list(ns0.MakeDirectory_Dec.__bases__) - bases.insert(0, ns0.MakeDirectoryRequestType_Def) - ns0.MakeDirectory_Dec.__bases__ = tuple(bases) - - ns0.MakeDirectoryRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MakeDirectory_Dec_Holder" - - class MakeDirectoryResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MakeDirectoryResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MakeDirectoryResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MakeDirectoryResponse") - kw["aname"] = "_MakeDirectoryResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MakeDirectoryResponse_Holder" - self.pyclass = Holder - - class ChangeOwner_Dec(ElementDeclaration): - literal = "ChangeOwner" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ChangeOwner") - kw["aname"] = "_ChangeOwner" - if ns0.ChangeOwnerRequestType_Def not in ns0.ChangeOwner_Dec.__bases__: - bases = list(ns0.ChangeOwner_Dec.__bases__) - bases.insert(0, ns0.ChangeOwnerRequestType_Def) - ns0.ChangeOwner_Dec.__bases__ = tuple(bases) - - ns0.ChangeOwnerRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ChangeOwner_Dec_Holder" - - class ChangeOwnerResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ChangeOwnerResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ChangeOwnerResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ChangeOwnerResponse") - kw["aname"] = "_ChangeOwnerResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ChangeOwnerResponse_Holder" - self.pyclass = Holder - - class CreateFolder_Dec(ElementDeclaration): - literal = "CreateFolder" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateFolder") - kw["aname"] = "_CreateFolder" - if ns0.CreateFolderRequestType_Def not in ns0.CreateFolder_Dec.__bases__: - bases = list(ns0.CreateFolder_Dec.__bases__) - bases.insert(0, ns0.CreateFolderRequestType_Def) - ns0.CreateFolder_Dec.__bases__ = tuple(bases) - - ns0.CreateFolderRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateFolder_Dec_Holder" - - class CreateFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateFolderResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateFolderResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateFolderResponse") - kw["aname"] = "_CreateFolderResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateFolderResponse_Holder" - self.pyclass = Holder - - class MoveIntoFolder_Dec(ElementDeclaration): - literal = "MoveIntoFolder" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveIntoFolder") - kw["aname"] = "_MoveIntoFolder" - if ns0.MoveIntoFolderRequestType_Def not in ns0.MoveIntoFolder_Dec.__bases__: - bases = list(ns0.MoveIntoFolder_Dec.__bases__) - bases.insert(0, ns0.MoveIntoFolderRequestType_Def) - ns0.MoveIntoFolder_Dec.__bases__ = tuple(bases) - - ns0.MoveIntoFolderRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveIntoFolder_Dec_Holder" - - class MoveIntoFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveIntoFolderResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveIntoFolderResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MoveIntoFolderResponse") - kw["aname"] = "_MoveIntoFolderResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MoveIntoFolderResponse_Holder" - self.pyclass = Holder - - class MoveIntoFolder_Task_Dec(ElementDeclaration): - literal = "MoveIntoFolder_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveIntoFolder_Task") - kw["aname"] = "_MoveIntoFolder_Task" - if ns0.MoveIntoFolderRequestType_Def not in ns0.MoveIntoFolder_Task_Dec.__bases__: - bases = list(ns0.MoveIntoFolder_Task_Dec.__bases__) - bases.insert(0, ns0.MoveIntoFolderRequestType_Def) - ns0.MoveIntoFolder_Task_Dec.__bases__ = tuple(bases) - - ns0.MoveIntoFolderRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveIntoFolder_Task_Dec_Holder" - - class MoveIntoFolder_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveIntoFolder_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveIntoFolder_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MoveIntoFolder_TaskResponse") - kw["aname"] = "_MoveIntoFolder_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MoveIntoFolder_TaskResponse_Holder" - self.pyclass = Holder - - class CreateVM_Dec(ElementDeclaration): - literal = "CreateVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateVM") - kw["aname"] = "_CreateVM" - if ns0.CreateVMRequestType_Def not in ns0.CreateVM_Dec.__bases__: - bases = list(ns0.CreateVM_Dec.__bases__) - bases.insert(0, ns0.CreateVMRequestType_Def) - ns0.CreateVM_Dec.__bases__ = tuple(bases) - - ns0.CreateVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateVM_Dec_Holder" - - class CreateVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateVMResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateVMResponse") - kw["aname"] = "_CreateVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateVMResponse_Holder" - self.pyclass = Holder - - class CreateVM_Task_Dec(ElementDeclaration): - literal = "CreateVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateVM_Task") - kw["aname"] = "_CreateVM_Task" - if ns0.CreateVMRequestType_Def not in ns0.CreateVM_Task_Dec.__bases__: - bases = list(ns0.CreateVM_Task_Dec.__bases__) - bases.insert(0, ns0.CreateVMRequestType_Def) - ns0.CreateVM_Task_Dec.__bases__ = tuple(bases) - - ns0.CreateVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateVM_Task_Dec_Holder" - - class CreateVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateVM_TaskResponse") - kw["aname"] = "_CreateVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateVM_TaskResponse_Holder" - self.pyclass = Holder - - class RegisterVM_Dec(ElementDeclaration): - literal = "RegisterVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RegisterVM") - kw["aname"] = "_RegisterVM" - if ns0.RegisterVMRequestType_Def not in ns0.RegisterVM_Dec.__bases__: - bases = list(ns0.RegisterVM_Dec.__bases__) - bases.insert(0, ns0.RegisterVMRequestType_Def) - ns0.RegisterVM_Dec.__bases__ = tuple(bases) - - ns0.RegisterVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RegisterVM_Dec_Holder" - - class RegisterVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RegisterVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RegisterVMResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RegisterVMResponse") - kw["aname"] = "_RegisterVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RegisterVMResponse_Holder" - self.pyclass = Holder - - class RegisterVM_Task_Dec(ElementDeclaration): - literal = "RegisterVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RegisterVM_Task") - kw["aname"] = "_RegisterVM_Task" - if ns0.RegisterVMRequestType_Def not in ns0.RegisterVM_Task_Dec.__bases__: - bases = list(ns0.RegisterVM_Task_Dec.__bases__) - bases.insert(0, ns0.RegisterVMRequestType_Def) - ns0.RegisterVM_Task_Dec.__bases__ = tuple(bases) - - ns0.RegisterVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RegisterVM_Task_Dec_Holder" - - class RegisterVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RegisterVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RegisterVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RegisterVM_TaskResponse") - kw["aname"] = "_RegisterVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RegisterVM_TaskResponse_Holder" - self.pyclass = Holder - - class CreateCluster_Dec(ElementDeclaration): - literal = "CreateCluster" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateCluster") - kw["aname"] = "_CreateCluster" - if ns0.CreateClusterRequestType_Def not in ns0.CreateCluster_Dec.__bases__: - bases = list(ns0.CreateCluster_Dec.__bases__) - bases.insert(0, ns0.CreateClusterRequestType_Def) - ns0.CreateCluster_Dec.__bases__ = tuple(bases) - - ns0.CreateClusterRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateCluster_Dec_Holder" - - class CreateClusterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateClusterResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateClusterResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateClusterResponse") - kw["aname"] = "_CreateClusterResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateClusterResponse_Holder" - self.pyclass = Holder - - class CreateClusterEx_Dec(ElementDeclaration): - literal = "CreateClusterEx" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateClusterEx") - kw["aname"] = "_CreateClusterEx" - if ns0.CreateClusterExRequestType_Def not in ns0.CreateClusterEx_Dec.__bases__: - bases = list(ns0.CreateClusterEx_Dec.__bases__) - bases.insert(0, ns0.CreateClusterExRequestType_Def) - ns0.CreateClusterEx_Dec.__bases__ = tuple(bases) - - ns0.CreateClusterExRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateClusterEx_Dec_Holder" - - class CreateClusterExResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateClusterExResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateClusterExResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateClusterExResponse") - kw["aname"] = "_CreateClusterExResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateClusterExResponse_Holder" - self.pyclass = Holder - - class AddStandaloneHost_Dec(ElementDeclaration): - literal = "AddStandaloneHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddStandaloneHost") - kw["aname"] = "_AddStandaloneHost" - if ns0.AddStandaloneHostRequestType_Def not in ns0.AddStandaloneHost_Dec.__bases__: - bases = list(ns0.AddStandaloneHost_Dec.__bases__) - bases.insert(0, ns0.AddStandaloneHostRequestType_Def) - ns0.AddStandaloneHost_Dec.__bases__ = tuple(bases) - - ns0.AddStandaloneHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddStandaloneHost_Dec_Holder" - - class AddStandaloneHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddStandaloneHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddStandaloneHostResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddStandaloneHostResponse") - kw["aname"] = "_AddStandaloneHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddStandaloneHostResponse_Holder" - self.pyclass = Holder - - class AddStandaloneHost_Task_Dec(ElementDeclaration): - literal = "AddStandaloneHost_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddStandaloneHost_Task") - kw["aname"] = "_AddStandaloneHost_Task" - if ns0.AddStandaloneHostRequestType_Def not in ns0.AddStandaloneHost_Task_Dec.__bases__: - bases = list(ns0.AddStandaloneHost_Task_Dec.__bases__) - bases.insert(0, ns0.AddStandaloneHostRequestType_Def) - ns0.AddStandaloneHost_Task_Dec.__bases__ = tuple(bases) - - ns0.AddStandaloneHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddStandaloneHost_Task_Dec_Holder" - - class AddStandaloneHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddStandaloneHost_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddStandaloneHost_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddStandaloneHost_TaskResponse") - kw["aname"] = "_AddStandaloneHost_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddStandaloneHost_TaskResponse_Holder" - self.pyclass = Holder - - class CreateDatacenter_Dec(ElementDeclaration): - literal = "CreateDatacenter" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateDatacenter") - kw["aname"] = "_CreateDatacenter" - if ns0.CreateDatacenterRequestType_Def not in ns0.CreateDatacenter_Dec.__bases__: - bases = list(ns0.CreateDatacenter_Dec.__bases__) - bases.insert(0, ns0.CreateDatacenterRequestType_Def) - ns0.CreateDatacenter_Dec.__bases__ = tuple(bases) - - ns0.CreateDatacenterRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateDatacenter_Dec_Holder" - - class CreateDatacenterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateDatacenterResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateDatacenterResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateDatacenterResponse") - kw["aname"] = "_CreateDatacenterResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateDatacenterResponse_Holder" - self.pyclass = Holder - - class UnregisterAndDestroy_Dec(ElementDeclaration): - literal = "UnregisterAndDestroy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnregisterAndDestroy") - kw["aname"] = "_UnregisterAndDestroy" - if ns0.UnregisterAndDestroyRequestType_Def not in ns0.UnregisterAndDestroy_Dec.__bases__: - bases = list(ns0.UnregisterAndDestroy_Dec.__bases__) - bases.insert(0, ns0.UnregisterAndDestroyRequestType_Def) - ns0.UnregisterAndDestroy_Dec.__bases__ = tuple(bases) - - ns0.UnregisterAndDestroyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnregisterAndDestroy_Dec_Holder" - - class UnregisterAndDestroyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UnregisterAndDestroyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UnregisterAndDestroyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UnregisterAndDestroyResponse") - kw["aname"] = "_UnregisterAndDestroyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UnregisterAndDestroyResponse_Holder" - self.pyclass = Holder - - class UnregisterAndDestroy_Task_Dec(ElementDeclaration): - literal = "UnregisterAndDestroy_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnregisterAndDestroy_Task") - kw["aname"] = "_UnregisterAndDestroy_Task" - if ns0.UnregisterAndDestroyRequestType_Def not in ns0.UnregisterAndDestroy_Task_Dec.__bases__: - bases = list(ns0.UnregisterAndDestroy_Task_Dec.__bases__) - bases.insert(0, ns0.UnregisterAndDestroyRequestType_Def) - ns0.UnregisterAndDestroy_Task_Dec.__bases__ = tuple(bases) - - ns0.UnregisterAndDestroyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnregisterAndDestroy_Task_Dec_Holder" - - class UnregisterAndDestroy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UnregisterAndDestroy_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UnregisterAndDestroy_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UnregisterAndDestroy_TaskResponse") - kw["aname"] = "_UnregisterAndDestroy_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UnregisterAndDestroy_TaskResponse_Holder" - self.pyclass = Holder - - class FolderCreateDVS_Dec(ElementDeclaration): - literal = "FolderCreateDVS" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FolderCreateDVS") - kw["aname"] = "_FolderCreateDVS" - if ns0.FolderCreateDVSRequestType_Def not in ns0.FolderCreateDVS_Dec.__bases__: - bases = list(ns0.FolderCreateDVS_Dec.__bases__) - bases.insert(0, ns0.FolderCreateDVSRequestType_Def) - ns0.FolderCreateDVS_Dec.__bases__ = tuple(bases) - - ns0.FolderCreateDVSRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FolderCreateDVS_Dec_Holder" - - class FolderCreateDVSResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FolderCreateDVSResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FolderCreateDVSResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FolderCreateDVSResponse") - kw["aname"] = "_FolderCreateDVSResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FolderCreateDVSResponse_Holder" - self.pyclass = Holder - - class SetCollectorPageSize_Dec(ElementDeclaration): - literal = "SetCollectorPageSize" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetCollectorPageSize") - kw["aname"] = "_SetCollectorPageSize" - if ns0.SetCollectorPageSizeRequestType_Def not in ns0.SetCollectorPageSize_Dec.__bases__: - bases = list(ns0.SetCollectorPageSize_Dec.__bases__) - bases.insert(0, ns0.SetCollectorPageSizeRequestType_Def) - ns0.SetCollectorPageSize_Dec.__bases__ = tuple(bases) - - ns0.SetCollectorPageSizeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetCollectorPageSize_Dec_Holder" - - class SetCollectorPageSizeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetCollectorPageSizeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetCollectorPageSizeResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetCollectorPageSizeResponse") - kw["aname"] = "_SetCollectorPageSizeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetCollectorPageSizeResponse_Holder" - self.pyclass = Holder - - class RewindCollector_Dec(ElementDeclaration): - literal = "RewindCollector" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RewindCollector") - kw["aname"] = "_RewindCollector" - if ns0.RewindCollectorRequestType_Def not in ns0.RewindCollector_Dec.__bases__: - bases = list(ns0.RewindCollector_Dec.__bases__) - bases.insert(0, ns0.RewindCollectorRequestType_Def) - ns0.RewindCollector_Dec.__bases__ = tuple(bases) - - ns0.RewindCollectorRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RewindCollector_Dec_Holder" - - class RewindCollectorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RewindCollectorResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RewindCollectorResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RewindCollectorResponse") - kw["aname"] = "_RewindCollectorResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RewindCollectorResponse_Holder" - self.pyclass = Holder - - class ResetCollector_Dec(ElementDeclaration): - literal = "ResetCollector" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetCollector") - kw["aname"] = "_ResetCollector" - if ns0.ResetCollectorRequestType_Def not in ns0.ResetCollector_Dec.__bases__: - bases = list(ns0.ResetCollector_Dec.__bases__) - bases.insert(0, ns0.ResetCollectorRequestType_Def) - ns0.ResetCollector_Dec.__bases__ = tuple(bases) - - ns0.ResetCollectorRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetCollector_Dec_Holder" - - class ResetCollectorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetCollectorResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetCollectorResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetCollectorResponse") - kw["aname"] = "_ResetCollectorResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetCollectorResponse_Holder" - self.pyclass = Holder - - class DestroyCollector_Dec(ElementDeclaration): - literal = "DestroyCollector" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestroyCollector") - kw["aname"] = "_DestroyCollector" - if ns0.DestroyCollectorRequestType_Def not in ns0.DestroyCollector_Dec.__bases__: - bases = list(ns0.DestroyCollector_Dec.__bases__) - bases.insert(0, ns0.DestroyCollectorRequestType_Def) - ns0.DestroyCollector_Dec.__bases__ = tuple(bases) - - ns0.DestroyCollectorRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestroyCollector_Dec_Holder" - - class DestroyCollectorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyCollectorResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyCollectorResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyCollectorResponse") - kw["aname"] = "_DestroyCollectorResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyCollectorResponse_Holder" - self.pyclass = Holder - - class QueryHostConnectionInfo_Dec(ElementDeclaration): - literal = "QueryHostConnectionInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryHostConnectionInfo") - kw["aname"] = "_QueryHostConnectionInfo" - if ns0.QueryHostConnectionInfoRequestType_Def not in ns0.QueryHostConnectionInfo_Dec.__bases__: - bases = list(ns0.QueryHostConnectionInfo_Dec.__bases__) - bases.insert(0, ns0.QueryHostConnectionInfoRequestType_Def) - ns0.QueryHostConnectionInfo_Dec.__bases__ = tuple(bases) - - ns0.QueryHostConnectionInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryHostConnectionInfo_Dec_Holder" - - class QueryHostConnectionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryHostConnectionInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryHostConnectionInfoResponse_Dec.schema - TClist = [GTD("urn:vim25","HostConnectInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryHostConnectionInfoResponse") - kw["aname"] = "_QueryHostConnectionInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryHostConnectionInfoResponse_Holder" - self.pyclass = Holder - - class UpdateSystemResources_Dec(ElementDeclaration): - literal = "UpdateSystemResources" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateSystemResources") - kw["aname"] = "_UpdateSystemResources" - if ns0.UpdateSystemResourcesRequestType_Def not in ns0.UpdateSystemResources_Dec.__bases__: - bases = list(ns0.UpdateSystemResources_Dec.__bases__) - bases.insert(0, ns0.UpdateSystemResourcesRequestType_Def) - ns0.UpdateSystemResources_Dec.__bases__ = tuple(bases) - - ns0.UpdateSystemResourcesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateSystemResources_Dec_Holder" - - class UpdateSystemResourcesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateSystemResourcesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateSystemResourcesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateSystemResourcesResponse") - kw["aname"] = "_UpdateSystemResourcesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateSystemResourcesResponse_Holder" - self.pyclass = Holder - - class ReconnectHost_Dec(ElementDeclaration): - literal = "ReconnectHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconnectHost") - kw["aname"] = "_ReconnectHost" - if ns0.ReconnectHostRequestType_Def not in ns0.ReconnectHost_Dec.__bases__: - bases = list(ns0.ReconnectHost_Dec.__bases__) - bases.insert(0, ns0.ReconnectHostRequestType_Def) - ns0.ReconnectHost_Dec.__bases__ = tuple(bases) - - ns0.ReconnectHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconnectHost_Dec_Holder" - - class ReconnectHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconnectHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconnectHostResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconnectHostResponse") - kw["aname"] = "_ReconnectHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconnectHostResponse_Holder" - self.pyclass = Holder - - class ReconnectHost_Task_Dec(ElementDeclaration): - literal = "ReconnectHost_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconnectHost_Task") - kw["aname"] = "_ReconnectHost_Task" - if ns0.ReconnectHostRequestType_Def not in ns0.ReconnectHost_Task_Dec.__bases__: - bases = list(ns0.ReconnectHost_Task_Dec.__bases__) - bases.insert(0, ns0.ReconnectHostRequestType_Def) - ns0.ReconnectHost_Task_Dec.__bases__ = tuple(bases) - - ns0.ReconnectHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconnectHost_Task_Dec_Holder" - - class ReconnectHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconnectHost_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconnectHost_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReconnectHost_TaskResponse") - kw["aname"] = "_ReconnectHost_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ReconnectHost_TaskResponse_Holder" - self.pyclass = Holder - - class DisconnectHost_Dec(ElementDeclaration): - literal = "DisconnectHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisconnectHost") - kw["aname"] = "_DisconnectHost" - if ns0.DisconnectHostRequestType_Def not in ns0.DisconnectHost_Dec.__bases__: - bases = list(ns0.DisconnectHost_Dec.__bases__) - bases.insert(0, ns0.DisconnectHostRequestType_Def) - ns0.DisconnectHost_Dec.__bases__ = tuple(bases) - - ns0.DisconnectHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisconnectHost_Dec_Holder" - - class DisconnectHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisconnectHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisconnectHostResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DisconnectHostResponse") - kw["aname"] = "_DisconnectHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DisconnectHostResponse_Holder" - self.pyclass = Holder - - class DisconnectHost_Task_Dec(ElementDeclaration): - literal = "DisconnectHost_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisconnectHost_Task") - kw["aname"] = "_DisconnectHost_Task" - if ns0.DisconnectHostRequestType_Def not in ns0.DisconnectHost_Task_Dec.__bases__: - bases = list(ns0.DisconnectHost_Task_Dec.__bases__) - bases.insert(0, ns0.DisconnectHostRequestType_Def) - ns0.DisconnectHost_Task_Dec.__bases__ = tuple(bases) - - ns0.DisconnectHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisconnectHost_Task_Dec_Holder" - - class DisconnectHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisconnectHost_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisconnectHost_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DisconnectHost_TaskResponse") - kw["aname"] = "_DisconnectHost_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DisconnectHost_TaskResponse_Holder" - self.pyclass = Holder - - class EnterMaintenanceMode_Dec(ElementDeclaration): - literal = "EnterMaintenanceMode" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnterMaintenanceMode") - kw["aname"] = "_EnterMaintenanceMode" - if ns0.EnterMaintenanceModeRequestType_Def not in ns0.EnterMaintenanceMode_Dec.__bases__: - bases = list(ns0.EnterMaintenanceMode_Dec.__bases__) - bases.insert(0, ns0.EnterMaintenanceModeRequestType_Def) - ns0.EnterMaintenanceMode_Dec.__bases__ = tuple(bases) - - ns0.EnterMaintenanceModeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnterMaintenanceMode_Dec_Holder" - - class EnterMaintenanceModeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnterMaintenanceModeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnterMaintenanceModeResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","EnterMaintenanceModeResponse") - kw["aname"] = "_EnterMaintenanceModeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "EnterMaintenanceModeResponse_Holder" - self.pyclass = Holder - - class EnterMaintenanceMode_Task_Dec(ElementDeclaration): - literal = "EnterMaintenanceMode_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnterMaintenanceMode_Task") - kw["aname"] = "_EnterMaintenanceMode_Task" - if ns0.EnterMaintenanceModeRequestType_Def not in ns0.EnterMaintenanceMode_Task_Dec.__bases__: - bases = list(ns0.EnterMaintenanceMode_Task_Dec.__bases__) - bases.insert(0, ns0.EnterMaintenanceModeRequestType_Def) - ns0.EnterMaintenanceMode_Task_Dec.__bases__ = tuple(bases) - - ns0.EnterMaintenanceModeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnterMaintenanceMode_Task_Dec_Holder" - - class EnterMaintenanceMode_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnterMaintenanceMode_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnterMaintenanceMode_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","EnterMaintenanceMode_TaskResponse") - kw["aname"] = "_EnterMaintenanceMode_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "EnterMaintenanceMode_TaskResponse_Holder" - self.pyclass = Holder - - class ExitMaintenanceMode_Dec(ElementDeclaration): - literal = "ExitMaintenanceMode" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExitMaintenanceMode") - kw["aname"] = "_ExitMaintenanceMode" - if ns0.ExitMaintenanceModeRequestType_Def not in ns0.ExitMaintenanceMode_Dec.__bases__: - bases = list(ns0.ExitMaintenanceMode_Dec.__bases__) - bases.insert(0, ns0.ExitMaintenanceModeRequestType_Def) - ns0.ExitMaintenanceMode_Dec.__bases__ = tuple(bases) - - ns0.ExitMaintenanceModeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExitMaintenanceMode_Dec_Holder" - - class ExitMaintenanceModeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExitMaintenanceModeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExitMaintenanceModeResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ExitMaintenanceModeResponse") - kw["aname"] = "_ExitMaintenanceModeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ExitMaintenanceModeResponse_Holder" - self.pyclass = Holder - - class ExitMaintenanceMode_Task_Dec(ElementDeclaration): - literal = "ExitMaintenanceMode_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExitMaintenanceMode_Task") - kw["aname"] = "_ExitMaintenanceMode_Task" - if ns0.ExitMaintenanceModeRequestType_Def not in ns0.ExitMaintenanceMode_Task_Dec.__bases__: - bases = list(ns0.ExitMaintenanceMode_Task_Dec.__bases__) - bases.insert(0, ns0.ExitMaintenanceModeRequestType_Def) - ns0.ExitMaintenanceMode_Task_Dec.__bases__ = tuple(bases) - - ns0.ExitMaintenanceModeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExitMaintenanceMode_Task_Dec_Holder" - - class ExitMaintenanceMode_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExitMaintenanceMode_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExitMaintenanceMode_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ExitMaintenanceMode_TaskResponse") - kw["aname"] = "_ExitMaintenanceMode_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ExitMaintenanceMode_TaskResponse_Holder" - self.pyclass = Holder - - class RebootHost_Dec(ElementDeclaration): - literal = "RebootHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RebootHost") - kw["aname"] = "_RebootHost" - if ns0.RebootHostRequestType_Def not in ns0.RebootHost_Dec.__bases__: - bases = list(ns0.RebootHost_Dec.__bases__) - bases.insert(0, ns0.RebootHostRequestType_Def) - ns0.RebootHost_Dec.__bases__ = tuple(bases) - - ns0.RebootHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RebootHost_Dec_Holder" - - class RebootHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RebootHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RebootHostResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RebootHostResponse") - kw["aname"] = "_RebootHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RebootHostResponse_Holder" - self.pyclass = Holder - - class RebootHost_Task_Dec(ElementDeclaration): - literal = "RebootHost_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RebootHost_Task") - kw["aname"] = "_RebootHost_Task" - if ns0.RebootHostRequestType_Def not in ns0.RebootHost_Task_Dec.__bases__: - bases = list(ns0.RebootHost_Task_Dec.__bases__) - bases.insert(0, ns0.RebootHostRequestType_Def) - ns0.RebootHost_Task_Dec.__bases__ = tuple(bases) - - ns0.RebootHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RebootHost_Task_Dec_Holder" - - class RebootHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RebootHost_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RebootHost_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RebootHost_TaskResponse") - kw["aname"] = "_RebootHost_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RebootHost_TaskResponse_Holder" - self.pyclass = Holder - - class ShutdownHost_Dec(ElementDeclaration): - literal = "ShutdownHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ShutdownHost") - kw["aname"] = "_ShutdownHost" - if ns0.ShutdownHostRequestType_Def not in ns0.ShutdownHost_Dec.__bases__: - bases = list(ns0.ShutdownHost_Dec.__bases__) - bases.insert(0, ns0.ShutdownHostRequestType_Def) - ns0.ShutdownHost_Dec.__bases__ = tuple(bases) - - ns0.ShutdownHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ShutdownHost_Dec_Holder" - - class ShutdownHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ShutdownHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ShutdownHostResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ShutdownHostResponse") - kw["aname"] = "_ShutdownHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ShutdownHostResponse_Holder" - self.pyclass = Holder - - class ShutdownHost_Task_Dec(ElementDeclaration): - literal = "ShutdownHost_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ShutdownHost_Task") - kw["aname"] = "_ShutdownHost_Task" - if ns0.ShutdownHostRequestType_Def not in ns0.ShutdownHost_Task_Dec.__bases__: - bases = list(ns0.ShutdownHost_Task_Dec.__bases__) - bases.insert(0, ns0.ShutdownHostRequestType_Def) - ns0.ShutdownHost_Task_Dec.__bases__ = tuple(bases) - - ns0.ShutdownHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ShutdownHost_Task_Dec_Holder" - - class ShutdownHost_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ShutdownHost_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ShutdownHost_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ShutdownHost_TaskResponse") - kw["aname"] = "_ShutdownHost_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ShutdownHost_TaskResponse_Holder" - self.pyclass = Holder - - class PowerDownHostToStandBy_Dec(ElementDeclaration): - literal = "PowerDownHostToStandBy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerDownHostToStandBy") - kw["aname"] = "_PowerDownHostToStandBy" - if ns0.PowerDownHostToStandByRequestType_Def not in ns0.PowerDownHostToStandBy_Dec.__bases__: - bases = list(ns0.PowerDownHostToStandBy_Dec.__bases__) - bases.insert(0, ns0.PowerDownHostToStandByRequestType_Def) - ns0.PowerDownHostToStandBy_Dec.__bases__ = tuple(bases) - - ns0.PowerDownHostToStandByRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerDownHostToStandBy_Dec_Holder" - - class PowerDownHostToStandByResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerDownHostToStandByResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerDownHostToStandByResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PowerDownHostToStandByResponse") - kw["aname"] = "_PowerDownHostToStandByResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PowerDownHostToStandByResponse_Holder" - self.pyclass = Holder - - class PowerDownHostToStandBy_Task_Dec(ElementDeclaration): - literal = "PowerDownHostToStandBy_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerDownHostToStandBy_Task") - kw["aname"] = "_PowerDownHostToStandBy_Task" - if ns0.PowerDownHostToStandByRequestType_Def not in ns0.PowerDownHostToStandBy_Task_Dec.__bases__: - bases = list(ns0.PowerDownHostToStandBy_Task_Dec.__bases__) - bases.insert(0, ns0.PowerDownHostToStandByRequestType_Def) - ns0.PowerDownHostToStandBy_Task_Dec.__bases__ = tuple(bases) - - ns0.PowerDownHostToStandByRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerDownHostToStandBy_Task_Dec_Holder" - - class PowerDownHostToStandBy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerDownHostToStandBy_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerDownHostToStandBy_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerDownHostToStandBy_TaskResponse") - kw["aname"] = "_PowerDownHostToStandBy_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerDownHostToStandBy_TaskResponse_Holder" - self.pyclass = Holder - - class PowerUpHostFromStandBy_Dec(ElementDeclaration): - literal = "PowerUpHostFromStandBy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerUpHostFromStandBy") - kw["aname"] = "_PowerUpHostFromStandBy" - if ns0.PowerUpHostFromStandByRequestType_Def not in ns0.PowerUpHostFromStandBy_Dec.__bases__: - bases = list(ns0.PowerUpHostFromStandBy_Dec.__bases__) - bases.insert(0, ns0.PowerUpHostFromStandByRequestType_Def) - ns0.PowerUpHostFromStandBy_Dec.__bases__ = tuple(bases) - - ns0.PowerUpHostFromStandByRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerUpHostFromStandBy_Dec_Holder" - - class PowerUpHostFromStandByResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerUpHostFromStandByResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerUpHostFromStandByResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PowerUpHostFromStandByResponse") - kw["aname"] = "_PowerUpHostFromStandByResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PowerUpHostFromStandByResponse_Holder" - self.pyclass = Holder - - class PowerUpHostFromStandBy_Task_Dec(ElementDeclaration): - literal = "PowerUpHostFromStandBy_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerUpHostFromStandBy_Task") - kw["aname"] = "_PowerUpHostFromStandBy_Task" - if ns0.PowerUpHostFromStandByRequestType_Def not in ns0.PowerUpHostFromStandBy_Task_Dec.__bases__: - bases = list(ns0.PowerUpHostFromStandBy_Task_Dec.__bases__) - bases.insert(0, ns0.PowerUpHostFromStandByRequestType_Def) - ns0.PowerUpHostFromStandBy_Task_Dec.__bases__ = tuple(bases) - - ns0.PowerUpHostFromStandByRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerUpHostFromStandBy_Task_Dec_Holder" - - class PowerUpHostFromStandBy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerUpHostFromStandBy_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerUpHostFromStandBy_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerUpHostFromStandBy_TaskResponse") - kw["aname"] = "_PowerUpHostFromStandBy_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerUpHostFromStandBy_TaskResponse_Holder" - self.pyclass = Holder - - class QueryMemoryOverhead_Dec(ElementDeclaration): - literal = "QueryMemoryOverhead" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryMemoryOverhead") - kw["aname"] = "_QueryMemoryOverhead" - if ns0.QueryMemoryOverheadRequestType_Def not in ns0.QueryMemoryOverhead_Dec.__bases__: - bases = list(ns0.QueryMemoryOverhead_Dec.__bases__) - bases.insert(0, ns0.QueryMemoryOverheadRequestType_Def) - ns0.QueryMemoryOverhead_Dec.__bases__ = tuple(bases) - - ns0.QueryMemoryOverheadRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryMemoryOverhead_Dec_Holder" - - class QueryMemoryOverheadResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryMemoryOverheadResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryMemoryOverheadResponse_Dec.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryMemoryOverheadResponse") - kw["aname"] = "_QueryMemoryOverheadResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryMemoryOverheadResponse_Holder" - self.pyclass = Holder - - class QueryMemoryOverheadEx_Dec(ElementDeclaration): - literal = "QueryMemoryOverheadEx" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryMemoryOverheadEx") - kw["aname"] = "_QueryMemoryOverheadEx" - if ns0.QueryMemoryOverheadExRequestType_Def not in ns0.QueryMemoryOverheadEx_Dec.__bases__: - bases = list(ns0.QueryMemoryOverheadEx_Dec.__bases__) - bases.insert(0, ns0.QueryMemoryOverheadExRequestType_Def) - ns0.QueryMemoryOverheadEx_Dec.__bases__ = tuple(bases) - - ns0.QueryMemoryOverheadExRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryMemoryOverheadEx_Dec_Holder" - - class QueryMemoryOverheadExResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryMemoryOverheadExResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryMemoryOverheadExResponse_Dec.schema - TClist = [ZSI.TCnumbers.Ilong(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryMemoryOverheadExResponse") - kw["aname"] = "_QueryMemoryOverheadExResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryMemoryOverheadExResponse_Holder" - self.pyclass = Holder - - class ReconfigureHostForDAS_Dec(ElementDeclaration): - literal = "ReconfigureHostForDAS" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureHostForDAS") - kw["aname"] = "_ReconfigureHostForDAS" - if ns0.ReconfigureHostForDASRequestType_Def not in ns0.ReconfigureHostForDAS_Dec.__bases__: - bases = list(ns0.ReconfigureHostForDAS_Dec.__bases__) - bases.insert(0, ns0.ReconfigureHostForDASRequestType_Def) - ns0.ReconfigureHostForDAS_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureHostForDASRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureHostForDAS_Dec_Holder" - - class ReconfigureHostForDASResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureHostForDASResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureHostForDASResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureHostForDASResponse") - kw["aname"] = "_ReconfigureHostForDASResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureHostForDASResponse_Holder" - self.pyclass = Holder - - class ReconfigureHostForDAS_Task_Dec(ElementDeclaration): - literal = "ReconfigureHostForDAS_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureHostForDAS_Task") - kw["aname"] = "_ReconfigureHostForDAS_Task" - if ns0.ReconfigureHostForDASRequestType_Def not in ns0.ReconfigureHostForDAS_Task_Dec.__bases__: - bases = list(ns0.ReconfigureHostForDAS_Task_Dec.__bases__) - bases.insert(0, ns0.ReconfigureHostForDASRequestType_Def) - ns0.ReconfigureHostForDAS_Task_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureHostForDASRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureHostForDAS_Task_Dec_Holder" - - class ReconfigureHostForDAS_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureHostForDAS_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureHostForDAS_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReconfigureHostForDAS_TaskResponse") - kw["aname"] = "_ReconfigureHostForDAS_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ReconfigureHostForDAS_TaskResponse_Holder" - self.pyclass = Holder - - class UpdateFlags_Dec(ElementDeclaration): - literal = "UpdateFlags" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateFlags") - kw["aname"] = "_UpdateFlags" - if ns0.UpdateFlagsRequestType_Def not in ns0.UpdateFlags_Dec.__bases__: - bases = list(ns0.UpdateFlags_Dec.__bases__) - bases.insert(0, ns0.UpdateFlagsRequestType_Def) - ns0.UpdateFlags_Dec.__bases__ = tuple(bases) - - ns0.UpdateFlagsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateFlags_Dec_Holder" - - class UpdateFlagsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateFlagsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateFlagsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateFlagsResponse") - kw["aname"] = "_UpdateFlagsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateFlagsResponse_Holder" - self.pyclass = Holder - - class AcquireCimServicesTicket_Dec(ElementDeclaration): - literal = "AcquireCimServicesTicket" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AcquireCimServicesTicket") - kw["aname"] = "_AcquireCimServicesTicket" - if ns0.AcquireCimServicesTicketRequestType_Def not in ns0.AcquireCimServicesTicket_Dec.__bases__: - bases = list(ns0.AcquireCimServicesTicket_Dec.__bases__) - bases.insert(0, ns0.AcquireCimServicesTicketRequestType_Def) - ns0.AcquireCimServicesTicket_Dec.__bases__ = tuple(bases) - - ns0.AcquireCimServicesTicketRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AcquireCimServicesTicket_Dec_Holder" - - class AcquireCimServicesTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AcquireCimServicesTicketResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AcquireCimServicesTicketResponse_Dec.schema - TClist = [GTD("urn:vim25","HostServiceTicket",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AcquireCimServicesTicketResponse") - kw["aname"] = "_AcquireCimServicesTicketResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AcquireCimServicesTicketResponse_Holder" - self.pyclass = Holder - - class UpdateIpmi_Dec(ElementDeclaration): - literal = "UpdateIpmi" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateIpmi") - kw["aname"] = "_UpdateIpmi" - if ns0.UpdateIpmiRequestType_Def not in ns0.UpdateIpmi_Dec.__bases__: - bases = list(ns0.UpdateIpmi_Dec.__bases__) - bases.insert(0, ns0.UpdateIpmiRequestType_Def) - ns0.UpdateIpmi_Dec.__bases__ = tuple(bases) - - ns0.UpdateIpmiRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpmi_Dec_Holder" - - class UpdateIpmiResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateIpmiResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateIpmiResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateIpmiResponse") - kw["aname"] = "_UpdateIpmiResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateIpmiResponse_Holder" - self.pyclass = Holder - - class HttpNfcLeaseComplete_Dec(ElementDeclaration): - literal = "HttpNfcLeaseComplete" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HttpNfcLeaseComplete") - kw["aname"] = "_HttpNfcLeaseComplete" - if ns0.HttpNfcLeaseCompleteRequestType_Def not in ns0.HttpNfcLeaseComplete_Dec.__bases__: - bases = list(ns0.HttpNfcLeaseComplete_Dec.__bases__) - bases.insert(0, ns0.HttpNfcLeaseCompleteRequestType_Def) - ns0.HttpNfcLeaseComplete_Dec.__bases__ = tuple(bases) - - ns0.HttpNfcLeaseCompleteRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HttpNfcLeaseComplete_Dec_Holder" - - class HttpNfcLeaseCompleteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HttpNfcLeaseCompleteResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HttpNfcLeaseCompleteResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","HttpNfcLeaseCompleteResponse") - kw["aname"] = "_HttpNfcLeaseCompleteResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "HttpNfcLeaseCompleteResponse_Holder" - self.pyclass = Holder - - class HttpNfcLeaseAbort_Dec(ElementDeclaration): - literal = "HttpNfcLeaseAbort" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HttpNfcLeaseAbort") - kw["aname"] = "_HttpNfcLeaseAbort" - if ns0.HttpNfcLeaseAbortRequestType_Def not in ns0.HttpNfcLeaseAbort_Dec.__bases__: - bases = list(ns0.HttpNfcLeaseAbort_Dec.__bases__) - bases.insert(0, ns0.HttpNfcLeaseAbortRequestType_Def) - ns0.HttpNfcLeaseAbort_Dec.__bases__ = tuple(bases) - - ns0.HttpNfcLeaseAbortRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HttpNfcLeaseAbort_Dec_Holder" - - class HttpNfcLeaseAbortResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HttpNfcLeaseAbortResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HttpNfcLeaseAbortResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","HttpNfcLeaseAbortResponse") - kw["aname"] = "_HttpNfcLeaseAbortResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "HttpNfcLeaseAbortResponse_Holder" - self.pyclass = Holder - - class HttpNfcLeaseProgress_Dec(ElementDeclaration): - literal = "HttpNfcLeaseProgress" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HttpNfcLeaseProgress") - kw["aname"] = "_HttpNfcLeaseProgress" - if ns0.HttpNfcLeaseProgressRequestType_Def not in ns0.HttpNfcLeaseProgress_Dec.__bases__: - bases = list(ns0.HttpNfcLeaseProgress_Dec.__bases__) - bases.insert(0, ns0.HttpNfcLeaseProgressRequestType_Def) - ns0.HttpNfcLeaseProgress_Dec.__bases__ = tuple(bases) - - ns0.HttpNfcLeaseProgressRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HttpNfcLeaseProgress_Dec_Holder" - - class HttpNfcLeaseProgressResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HttpNfcLeaseProgressResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HttpNfcLeaseProgressResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","HttpNfcLeaseProgressResponse") - kw["aname"] = "_HttpNfcLeaseProgressResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "HttpNfcLeaseProgressResponse_Holder" - self.pyclass = Holder - - class QueryIpPools_Dec(ElementDeclaration): - literal = "QueryIpPools" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryIpPools") - kw["aname"] = "_QueryIpPools" - if ns0.QueryIpPoolsRequestType_Def not in ns0.QueryIpPools_Dec.__bases__: - bases = list(ns0.QueryIpPools_Dec.__bases__) - bases.insert(0, ns0.QueryIpPoolsRequestType_Def) - ns0.QueryIpPools_Dec.__bases__ = tuple(bases) - - ns0.QueryIpPoolsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryIpPools_Dec_Holder" - - class QueryIpPoolsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryIpPoolsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryIpPoolsResponse_Dec.schema - TClist = [GTD("urn:vim25","IpPool",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryIpPoolsResponse") - kw["aname"] = "_QueryIpPoolsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryIpPoolsResponse_Holder" - self.pyclass = Holder - - class CreateIpPool_Dec(ElementDeclaration): - literal = "CreateIpPool" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateIpPool") - kw["aname"] = "_CreateIpPool" - if ns0.CreateIpPoolRequestType_Def not in ns0.CreateIpPool_Dec.__bases__: - bases = list(ns0.CreateIpPool_Dec.__bases__) - bases.insert(0, ns0.CreateIpPoolRequestType_Def) - ns0.CreateIpPool_Dec.__bases__ = tuple(bases) - - ns0.CreateIpPoolRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateIpPool_Dec_Holder" - - class CreateIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateIpPoolResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateIpPoolResponse_Dec.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateIpPoolResponse") - kw["aname"] = "_CreateIpPoolResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateIpPoolResponse_Holder" - self.pyclass = Holder - - class UpdateIpPool_Dec(ElementDeclaration): - literal = "UpdateIpPool" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateIpPool") - kw["aname"] = "_UpdateIpPool" - if ns0.UpdateIpPoolRequestType_Def not in ns0.UpdateIpPool_Dec.__bases__: - bases = list(ns0.UpdateIpPool_Dec.__bases__) - bases.insert(0, ns0.UpdateIpPoolRequestType_Def) - ns0.UpdateIpPool_Dec.__bases__ = tuple(bases) - - ns0.UpdateIpPoolRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpPool_Dec_Holder" - - class UpdateIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateIpPoolResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateIpPoolResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateIpPoolResponse") - kw["aname"] = "_UpdateIpPoolResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateIpPoolResponse_Holder" - self.pyclass = Holder - - class DestroyIpPool_Dec(ElementDeclaration): - literal = "DestroyIpPool" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestroyIpPool") - kw["aname"] = "_DestroyIpPool" - if ns0.DestroyIpPoolRequestType_Def not in ns0.DestroyIpPool_Dec.__bases__: - bases = list(ns0.DestroyIpPool_Dec.__bases__) - bases.insert(0, ns0.DestroyIpPoolRequestType_Def) - ns0.DestroyIpPool_Dec.__bases__ = tuple(bases) - - ns0.DestroyIpPoolRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestroyIpPool_Dec_Holder" - - class DestroyIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyIpPoolResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyIpPoolResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyIpPoolResponse") - kw["aname"] = "_DestroyIpPoolResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyIpPoolResponse_Holder" - self.pyclass = Holder - - class AssociateIpPool_Dec(ElementDeclaration): - literal = "AssociateIpPool" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AssociateIpPool") - kw["aname"] = "_AssociateIpPool" - if ns0.AssociateIpPoolRequestType_Def not in ns0.AssociateIpPool_Dec.__bases__: - bases = list(ns0.AssociateIpPool_Dec.__bases__) - bases.insert(0, ns0.AssociateIpPoolRequestType_Def) - ns0.AssociateIpPool_Dec.__bases__ = tuple(bases) - - ns0.AssociateIpPoolRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AssociateIpPool_Dec_Holder" - - class AssociateIpPoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AssociateIpPoolResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AssociateIpPoolResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AssociateIpPoolResponse") - kw["aname"] = "_AssociateIpPoolResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AssociateIpPoolResponse_Holder" - self.pyclass = Holder - - class UpdateAssignedLicense_Dec(ElementDeclaration): - literal = "UpdateAssignedLicense" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateAssignedLicense") - kw["aname"] = "_UpdateAssignedLicense" - if ns0.UpdateAssignedLicenseRequestType_Def not in ns0.UpdateAssignedLicense_Dec.__bases__: - bases = list(ns0.UpdateAssignedLicense_Dec.__bases__) - bases.insert(0, ns0.UpdateAssignedLicenseRequestType_Def) - ns0.UpdateAssignedLicense_Dec.__bases__ = tuple(bases) - - ns0.UpdateAssignedLicenseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateAssignedLicense_Dec_Holder" - - class UpdateAssignedLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateAssignedLicenseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateAssignedLicenseResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UpdateAssignedLicenseResponse") - kw["aname"] = "_UpdateAssignedLicenseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UpdateAssignedLicenseResponse_Holder" - self.pyclass = Holder - - class RemoveAssignedLicense_Dec(ElementDeclaration): - literal = "RemoveAssignedLicense" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveAssignedLicense") - kw["aname"] = "_RemoveAssignedLicense" - if ns0.RemoveAssignedLicenseRequestType_Def not in ns0.RemoveAssignedLicense_Dec.__bases__: - bases = list(ns0.RemoveAssignedLicense_Dec.__bases__) - bases.insert(0, ns0.RemoveAssignedLicenseRequestType_Def) - ns0.RemoveAssignedLicense_Dec.__bases__ = tuple(bases) - - ns0.RemoveAssignedLicenseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveAssignedLicense_Dec_Holder" - - class RemoveAssignedLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveAssignedLicenseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveAssignedLicenseResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveAssignedLicenseResponse") - kw["aname"] = "_RemoveAssignedLicenseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveAssignedLicenseResponse_Holder" - self.pyclass = Holder - - class QueryAssignedLicenses_Dec(ElementDeclaration): - literal = "QueryAssignedLicenses" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryAssignedLicenses") - kw["aname"] = "_QueryAssignedLicenses" - if ns0.QueryAssignedLicensesRequestType_Def not in ns0.QueryAssignedLicenses_Dec.__bases__: - bases = list(ns0.QueryAssignedLicenses_Dec.__bases__) - bases.insert(0, ns0.QueryAssignedLicensesRequestType_Def) - ns0.QueryAssignedLicenses_Dec.__bases__ = tuple(bases) - - ns0.QueryAssignedLicensesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryAssignedLicenses_Dec_Holder" - - class QueryAssignedLicensesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryAssignedLicensesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryAssignedLicensesResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseAssignmentManagerLicenseAssignment",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryAssignedLicensesResponse") - kw["aname"] = "_QueryAssignedLicensesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryAssignedLicensesResponse_Holder" - self.pyclass = Holder - - class IsFeatureAvailable_Dec(ElementDeclaration): - literal = "IsFeatureAvailable" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IsFeatureAvailable") - kw["aname"] = "_IsFeatureAvailable" - if ns0.IsFeatureAvailableRequestType_Def not in ns0.IsFeatureAvailable_Dec.__bases__: - bases = list(ns0.IsFeatureAvailable_Dec.__bases__) - bases.insert(0, ns0.IsFeatureAvailableRequestType_Def) - ns0.IsFeatureAvailable_Dec.__bases__ = tuple(bases) - - ns0.IsFeatureAvailableRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IsFeatureAvailable_Dec_Holder" - - class IsFeatureAvailableResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "IsFeatureAvailableResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.IsFeatureAvailableResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseAssignmentManagerFeatureLicenseAvailability",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","IsFeatureAvailableResponse") - kw["aname"] = "_IsFeatureAvailableResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "IsFeatureAvailableResponse_Holder" - self.pyclass = Holder - - class SetFeatureInUse_Dec(ElementDeclaration): - literal = "SetFeatureInUse" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetFeatureInUse") - kw["aname"] = "_SetFeatureInUse" - if ns0.SetFeatureInUseRequestType_Def not in ns0.SetFeatureInUse_Dec.__bases__: - bases = list(ns0.SetFeatureInUse_Dec.__bases__) - bases.insert(0, ns0.SetFeatureInUseRequestType_Def) - ns0.SetFeatureInUse_Dec.__bases__ = tuple(bases) - - ns0.SetFeatureInUseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetFeatureInUse_Dec_Holder" - - class SetFeatureInUseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetFeatureInUseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetFeatureInUseResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetFeatureInUseResponse") - kw["aname"] = "_SetFeatureInUseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetFeatureInUseResponse_Holder" - self.pyclass = Holder - - class ResetFeatureInUse_Dec(ElementDeclaration): - literal = "ResetFeatureInUse" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetFeatureInUse") - kw["aname"] = "_ResetFeatureInUse" - if ns0.ResetFeatureInUseRequestType_Def not in ns0.ResetFeatureInUse_Dec.__bases__: - bases = list(ns0.ResetFeatureInUse_Dec.__bases__) - bases.insert(0, ns0.ResetFeatureInUseRequestType_Def) - ns0.ResetFeatureInUse_Dec.__bases__ = tuple(bases) - - ns0.ResetFeatureInUseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetFeatureInUse_Dec_Holder" - - class ResetFeatureInUseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetFeatureInUseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetFeatureInUseResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetFeatureInUseResponse") - kw["aname"] = "_ResetFeatureInUseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetFeatureInUseResponse_Holder" - self.pyclass = Holder - - class QuerySupportedFeatures_Dec(ElementDeclaration): - literal = "QuerySupportedFeatures" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QuerySupportedFeatures") - kw["aname"] = "_QuerySupportedFeatures" - if ns0.QuerySupportedFeaturesRequestType_Def not in ns0.QuerySupportedFeatures_Dec.__bases__: - bases = list(ns0.QuerySupportedFeatures_Dec.__bases__) - bases.insert(0, ns0.QuerySupportedFeaturesRequestType_Def) - ns0.QuerySupportedFeatures_Dec.__bases__ = tuple(bases) - - ns0.QuerySupportedFeaturesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QuerySupportedFeatures_Dec_Holder" - - class QuerySupportedFeaturesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QuerySupportedFeaturesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QuerySupportedFeaturesResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseFeatureInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QuerySupportedFeaturesResponse") - kw["aname"] = "_QuerySupportedFeaturesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QuerySupportedFeaturesResponse_Holder" - self.pyclass = Holder - - class QueryLicenseSourceAvailability_Dec(ElementDeclaration): - literal = "QueryLicenseSourceAvailability" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryLicenseSourceAvailability") - kw["aname"] = "_QueryLicenseSourceAvailability" - if ns0.QueryLicenseSourceAvailabilityRequestType_Def not in ns0.QueryLicenseSourceAvailability_Dec.__bases__: - bases = list(ns0.QueryLicenseSourceAvailability_Dec.__bases__) - bases.insert(0, ns0.QueryLicenseSourceAvailabilityRequestType_Def) - ns0.QueryLicenseSourceAvailability_Dec.__bases__ = tuple(bases) - - ns0.QueryLicenseSourceAvailabilityRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryLicenseSourceAvailability_Dec_Holder" - - class QueryLicenseSourceAvailabilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryLicenseSourceAvailabilityResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryLicenseSourceAvailabilityResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseAvailabilityInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryLicenseSourceAvailabilityResponse") - kw["aname"] = "_QueryLicenseSourceAvailabilityResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryLicenseSourceAvailabilityResponse_Holder" - self.pyclass = Holder - - class QueryLicenseUsage_Dec(ElementDeclaration): - literal = "QueryLicenseUsage" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryLicenseUsage") - kw["aname"] = "_QueryLicenseUsage" - if ns0.QueryLicenseUsageRequestType_Def not in ns0.QueryLicenseUsage_Dec.__bases__: - bases = list(ns0.QueryLicenseUsage_Dec.__bases__) - bases.insert(0, ns0.QueryLicenseUsageRequestType_Def) - ns0.QueryLicenseUsage_Dec.__bases__ = tuple(bases) - - ns0.QueryLicenseUsageRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryLicenseUsage_Dec_Holder" - - class QueryLicenseUsageResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryLicenseUsageResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryLicenseUsageResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseUsageInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryLicenseUsageResponse") - kw["aname"] = "_QueryLicenseUsageResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryLicenseUsageResponse_Holder" - self.pyclass = Holder - - class SetLicenseEdition_Dec(ElementDeclaration): - literal = "SetLicenseEdition" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetLicenseEdition") - kw["aname"] = "_SetLicenseEdition" - if ns0.SetLicenseEditionRequestType_Def not in ns0.SetLicenseEdition_Dec.__bases__: - bases = list(ns0.SetLicenseEdition_Dec.__bases__) - bases.insert(0, ns0.SetLicenseEditionRequestType_Def) - ns0.SetLicenseEdition_Dec.__bases__ = tuple(bases) - - ns0.SetLicenseEditionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetLicenseEdition_Dec_Holder" - - class SetLicenseEditionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetLicenseEditionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetLicenseEditionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetLicenseEditionResponse") - kw["aname"] = "_SetLicenseEditionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetLicenseEditionResponse_Holder" - self.pyclass = Holder - - class CheckLicenseFeature_Dec(ElementDeclaration): - literal = "CheckLicenseFeature" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckLicenseFeature") - kw["aname"] = "_CheckLicenseFeature" - if ns0.CheckLicenseFeatureRequestType_Def not in ns0.CheckLicenseFeature_Dec.__bases__: - bases = list(ns0.CheckLicenseFeature_Dec.__bases__) - bases.insert(0, ns0.CheckLicenseFeatureRequestType_Def) - ns0.CheckLicenseFeature_Dec.__bases__ = tuple(bases) - - ns0.CheckLicenseFeatureRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckLicenseFeature_Dec_Holder" - - class CheckLicenseFeatureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckLicenseFeatureResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckLicenseFeatureResponse_Dec.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckLicenseFeatureResponse") - kw["aname"] = "_CheckLicenseFeatureResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CheckLicenseFeatureResponse_Holder" - self.pyclass = Holder - - class EnableFeature_Dec(ElementDeclaration): - literal = "EnableFeature" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnableFeature") - kw["aname"] = "_EnableFeature" - if ns0.EnableFeatureRequestType_Def not in ns0.EnableFeature_Dec.__bases__: - bases = list(ns0.EnableFeature_Dec.__bases__) - bases.insert(0, ns0.EnableFeatureRequestType_Def) - ns0.EnableFeature_Dec.__bases__ = tuple(bases) - - ns0.EnableFeatureRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnableFeature_Dec_Holder" - - class EnableFeatureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnableFeatureResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnableFeatureResponse_Dec.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","EnableFeatureResponse") - kw["aname"] = "_EnableFeatureResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "EnableFeatureResponse_Holder" - self.pyclass = Holder - - class DisableFeature_Dec(ElementDeclaration): - literal = "DisableFeature" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisableFeature") - kw["aname"] = "_DisableFeature" - if ns0.DisableFeatureRequestType_Def not in ns0.DisableFeature_Dec.__bases__: - bases = list(ns0.DisableFeature_Dec.__bases__) - bases.insert(0, ns0.DisableFeatureRequestType_Def) - ns0.DisableFeature_Dec.__bases__ = tuple(bases) - - ns0.DisableFeatureRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisableFeature_Dec_Holder" - - class DisableFeatureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisableFeatureResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisableFeatureResponse_Dec.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DisableFeatureResponse") - kw["aname"] = "_DisableFeatureResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DisableFeatureResponse_Holder" - self.pyclass = Holder - - class ConfigureLicenseSource_Dec(ElementDeclaration): - literal = "ConfigureLicenseSource" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ConfigureLicenseSource") - kw["aname"] = "_ConfigureLicenseSource" - if ns0.ConfigureLicenseSourceRequestType_Def not in ns0.ConfigureLicenseSource_Dec.__bases__: - bases = list(ns0.ConfigureLicenseSource_Dec.__bases__) - bases.insert(0, ns0.ConfigureLicenseSourceRequestType_Def) - ns0.ConfigureLicenseSource_Dec.__bases__ = tuple(bases) - - ns0.ConfigureLicenseSourceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ConfigureLicenseSource_Dec_Holder" - - class ConfigureLicenseSourceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ConfigureLicenseSourceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ConfigureLicenseSourceResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ConfigureLicenseSourceResponse") - kw["aname"] = "_ConfigureLicenseSourceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ConfigureLicenseSourceResponse_Holder" - self.pyclass = Holder - - class UpdateLicense_Dec(ElementDeclaration): - literal = "UpdateLicense" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateLicense") - kw["aname"] = "_UpdateLicense" - if ns0.UpdateLicenseRequestType_Def not in ns0.UpdateLicense_Dec.__bases__: - bases = list(ns0.UpdateLicense_Dec.__bases__) - bases.insert(0, ns0.UpdateLicenseRequestType_Def) - ns0.UpdateLicense_Dec.__bases__ = tuple(bases) - - ns0.UpdateLicenseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateLicense_Dec_Holder" - - class UpdateLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateLicenseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateLicenseResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UpdateLicenseResponse") - kw["aname"] = "_UpdateLicenseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UpdateLicenseResponse_Holder" - self.pyclass = Holder - - class AddLicense_Dec(ElementDeclaration): - literal = "AddLicense" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddLicense") - kw["aname"] = "_AddLicense" - if ns0.AddLicenseRequestType_Def not in ns0.AddLicense_Dec.__bases__: - bases = list(ns0.AddLicense_Dec.__bases__) - bases.insert(0, ns0.AddLicenseRequestType_Def) - ns0.AddLicense_Dec.__bases__ = tuple(bases) - - ns0.AddLicenseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddLicense_Dec_Holder" - - class AddLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddLicenseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddLicenseResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddLicenseResponse") - kw["aname"] = "_AddLicenseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddLicenseResponse_Holder" - self.pyclass = Holder - - class RemoveLicense_Dec(ElementDeclaration): - literal = "RemoveLicense" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveLicense") - kw["aname"] = "_RemoveLicense" - if ns0.RemoveLicenseRequestType_Def not in ns0.RemoveLicense_Dec.__bases__: - bases = list(ns0.RemoveLicense_Dec.__bases__) - bases.insert(0, ns0.RemoveLicenseRequestType_Def) - ns0.RemoveLicense_Dec.__bases__ = tuple(bases) - - ns0.RemoveLicenseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveLicense_Dec_Holder" - - class RemoveLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveLicenseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveLicenseResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveLicenseResponse") - kw["aname"] = "_RemoveLicenseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveLicenseResponse_Holder" - self.pyclass = Holder - - class DecodeLicense_Dec(ElementDeclaration): - literal = "DecodeLicense" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DecodeLicense") - kw["aname"] = "_DecodeLicense" - if ns0.DecodeLicenseRequestType_Def not in ns0.DecodeLicense_Dec.__bases__: - bases = list(ns0.DecodeLicense_Dec.__bases__) - bases.insert(0, ns0.DecodeLicenseRequestType_Def) - ns0.DecodeLicense_Dec.__bases__ = tuple(bases) - - ns0.DecodeLicenseRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DecodeLicense_Dec_Holder" - - class DecodeLicenseResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DecodeLicenseResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DecodeLicenseResponse_Dec.schema - TClist = [GTD("urn:vim25","LicenseManagerLicenseInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DecodeLicenseResponse") - kw["aname"] = "_DecodeLicenseResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DecodeLicenseResponse_Holder" - self.pyclass = Holder - - class UpdateLicenseLabel_Dec(ElementDeclaration): - literal = "UpdateLicenseLabel" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateLicenseLabel") - kw["aname"] = "_UpdateLicenseLabel" - if ns0.UpdateLicenseLabelRequestType_Def not in ns0.UpdateLicenseLabel_Dec.__bases__: - bases = list(ns0.UpdateLicenseLabel_Dec.__bases__) - bases.insert(0, ns0.UpdateLicenseLabelRequestType_Def) - ns0.UpdateLicenseLabel_Dec.__bases__ = tuple(bases) - - ns0.UpdateLicenseLabelRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateLicenseLabel_Dec_Holder" - - class UpdateLicenseLabelResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateLicenseLabelResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateLicenseLabelResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateLicenseLabelResponse") - kw["aname"] = "_UpdateLicenseLabelResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateLicenseLabelResponse_Holder" - self.pyclass = Holder - - class RemoveLicenseLabel_Dec(ElementDeclaration): - literal = "RemoveLicenseLabel" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveLicenseLabel") - kw["aname"] = "_RemoveLicenseLabel" - if ns0.RemoveLicenseLabelRequestType_Def not in ns0.RemoveLicenseLabel_Dec.__bases__: - bases = list(ns0.RemoveLicenseLabel_Dec.__bases__) - bases.insert(0, ns0.RemoveLicenseLabelRequestType_Def) - ns0.RemoveLicenseLabel_Dec.__bases__ = tuple(bases) - - ns0.RemoveLicenseLabelRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveLicenseLabel_Dec_Holder" - - class RemoveLicenseLabelResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveLicenseLabelResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveLicenseLabelResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveLicenseLabelResponse") - kw["aname"] = "_RemoveLicenseLabelResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveLicenseLabelResponse_Holder" - self.pyclass = Holder - - class Reload_Dec(ElementDeclaration): - literal = "Reload" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Reload") - kw["aname"] = "_Reload" - if ns0.ReloadRequestType_Def not in ns0.Reload_Dec.__bases__: - bases = list(ns0.Reload_Dec.__bases__) - bases.insert(0, ns0.ReloadRequestType_Def) - ns0.Reload_Dec.__bases__ = tuple(bases) - - ns0.ReloadRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Reload_Dec_Holder" - - class ReloadResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReloadResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReloadResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReloadResponse") - kw["aname"] = "_ReloadResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReloadResponse_Holder" - self.pyclass = Holder - - class Rename_Dec(ElementDeclaration): - literal = "Rename" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Rename") - kw["aname"] = "_Rename" - if ns0.RenameRequestType_Def not in ns0.Rename_Dec.__bases__: - bases = list(ns0.Rename_Dec.__bases__) - bases.insert(0, ns0.RenameRequestType_Def) - ns0.Rename_Dec.__bases__ = tuple(bases) - - ns0.RenameRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Rename_Dec_Holder" - - class RenameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RenameResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RenameResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RenameResponse") - kw["aname"] = "_RenameResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RenameResponse_Holder" - self.pyclass = Holder - - class Rename_Task_Dec(ElementDeclaration): - literal = "Rename_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Rename_Task") - kw["aname"] = "_Rename_Task" - if ns0.RenameRequestType_Def not in ns0.Rename_Task_Dec.__bases__: - bases = list(ns0.Rename_Task_Dec.__bases__) - bases.insert(0, ns0.RenameRequestType_Def) - ns0.Rename_Task_Dec.__bases__ = tuple(bases) - - ns0.RenameRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Rename_Task_Dec_Holder" - - class Rename_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "Rename_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.Rename_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","Rename_TaskResponse") - kw["aname"] = "_Rename_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "Rename_TaskResponse_Holder" - self.pyclass = Holder - - class Destroy_Dec(ElementDeclaration): - literal = "Destroy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Destroy") - kw["aname"] = "_Destroy" - if ns0.DestroyRequestType_Def not in ns0.Destroy_Dec.__bases__: - bases = list(ns0.Destroy_Dec.__bases__) - bases.insert(0, ns0.DestroyRequestType_Def) - ns0.Destroy_Dec.__bases__ = tuple(bases) - - ns0.DestroyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Destroy_Dec_Holder" - - class DestroyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyResponse") - kw["aname"] = "_DestroyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyResponse_Holder" - self.pyclass = Holder - - class Destroy_Task_Dec(ElementDeclaration): - literal = "Destroy_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Destroy_Task") - kw["aname"] = "_Destroy_Task" - if ns0.DestroyRequestType_Def not in ns0.Destroy_Task_Dec.__bases__: - bases = list(ns0.Destroy_Task_Dec.__bases__) - bases.insert(0, ns0.DestroyRequestType_Def) - ns0.Destroy_Task_Dec.__bases__ = tuple(bases) - - ns0.DestroyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Destroy_Task_Dec_Holder" - - class Destroy_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "Destroy_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.Destroy_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","Destroy_TaskResponse") - kw["aname"] = "_Destroy_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "Destroy_TaskResponse_Holder" - self.pyclass = Holder - - class DestroyNetwork_Dec(ElementDeclaration): - literal = "DestroyNetwork" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestroyNetwork") - kw["aname"] = "_DestroyNetwork" - if ns0.DestroyNetworkRequestType_Def not in ns0.DestroyNetwork_Dec.__bases__: - bases = list(ns0.DestroyNetwork_Dec.__bases__) - bases.insert(0, ns0.DestroyNetworkRequestType_Def) - ns0.DestroyNetwork_Dec.__bases__ = tuple(bases) - - ns0.DestroyNetworkRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestroyNetwork_Dec_Holder" - - class DestroyNetworkResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyNetworkResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyNetworkResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyNetworkResponse") - kw["aname"] = "_DestroyNetworkResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyNetworkResponse_Holder" - self.pyclass = Holder - - class ValidateHost_Dec(ElementDeclaration): - literal = "ValidateHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ValidateHost") - kw["aname"] = "_ValidateHost" - if ns0.ValidateHostRequestType_Def not in ns0.ValidateHost_Dec.__bases__: - bases = list(ns0.ValidateHost_Dec.__bases__) - bases.insert(0, ns0.ValidateHostRequestType_Def) - ns0.ValidateHost_Dec.__bases__ = tuple(bases) - - ns0.ValidateHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ValidateHost_Dec_Holder" - - class ValidateHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ValidateHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ValidateHostResponse_Dec.schema - TClist = [GTD("urn:vim25","OvfValidateHostResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ValidateHostResponse") - kw["aname"] = "_ValidateHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ValidateHostResponse_Holder" - self.pyclass = Holder - - class ParseDescriptor_Dec(ElementDeclaration): - literal = "ParseDescriptor" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ParseDescriptor") - kw["aname"] = "_ParseDescriptor" - if ns0.ParseDescriptorRequestType_Def not in ns0.ParseDescriptor_Dec.__bases__: - bases = list(ns0.ParseDescriptor_Dec.__bases__) - bases.insert(0, ns0.ParseDescriptorRequestType_Def) - ns0.ParseDescriptor_Dec.__bases__ = tuple(bases) - - ns0.ParseDescriptorRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ParseDescriptor_Dec_Holder" - - class ParseDescriptorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ParseDescriptorResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ParseDescriptorResponse_Dec.schema - TClist = [GTD("urn:vim25","OvfParseDescriptorResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ParseDescriptorResponse") - kw["aname"] = "_ParseDescriptorResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ParseDescriptorResponse_Holder" - self.pyclass = Holder - - class CreateImportSpec_Dec(ElementDeclaration): - literal = "CreateImportSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateImportSpec") - kw["aname"] = "_CreateImportSpec" - if ns0.CreateImportSpecRequestType_Def not in ns0.CreateImportSpec_Dec.__bases__: - bases = list(ns0.CreateImportSpec_Dec.__bases__) - bases.insert(0, ns0.CreateImportSpecRequestType_Def) - ns0.CreateImportSpec_Dec.__bases__ = tuple(bases) - - ns0.CreateImportSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateImportSpec_Dec_Holder" - - class CreateImportSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateImportSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateImportSpecResponse_Dec.schema - TClist = [GTD("urn:vim25","OvfCreateImportSpecResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateImportSpecResponse") - kw["aname"] = "_CreateImportSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateImportSpecResponse_Holder" - self.pyclass = Holder - - class CreateDescriptor_Dec(ElementDeclaration): - literal = "CreateDescriptor" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateDescriptor") - kw["aname"] = "_CreateDescriptor" - if ns0.CreateDescriptorRequestType_Def not in ns0.CreateDescriptor_Dec.__bases__: - bases = list(ns0.CreateDescriptor_Dec.__bases__) - bases.insert(0, ns0.CreateDescriptorRequestType_Def) - ns0.CreateDescriptor_Dec.__bases__ = tuple(bases) - - ns0.CreateDescriptorRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateDescriptor_Dec_Holder" - - class CreateDescriptorResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateDescriptorResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateDescriptorResponse_Dec.schema - TClist = [GTD("urn:vim25","OvfCreateDescriptorResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateDescriptorResponse") - kw["aname"] = "_CreateDescriptorResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateDescriptorResponse_Holder" - self.pyclass = Holder - - class QueryPerfProviderSummary_Dec(ElementDeclaration): - literal = "QueryPerfProviderSummary" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPerfProviderSummary") - kw["aname"] = "_QueryPerfProviderSummary" - if ns0.QueryPerfProviderSummaryRequestType_Def not in ns0.QueryPerfProviderSummary_Dec.__bases__: - bases = list(ns0.QueryPerfProviderSummary_Dec.__bases__) - bases.insert(0, ns0.QueryPerfProviderSummaryRequestType_Def) - ns0.QueryPerfProviderSummary_Dec.__bases__ = tuple(bases) - - ns0.QueryPerfProviderSummaryRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfProviderSummary_Dec_Holder" - - class QueryPerfProviderSummaryResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPerfProviderSummaryResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPerfProviderSummaryResponse_Dec.schema - TClist = [GTD("urn:vim25","PerfProviderSummary",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPerfProviderSummaryResponse") - kw["aname"] = "_QueryPerfProviderSummaryResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryPerfProviderSummaryResponse_Holder" - self.pyclass = Holder - - class QueryAvailablePerfMetric_Dec(ElementDeclaration): - literal = "QueryAvailablePerfMetric" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryAvailablePerfMetric") - kw["aname"] = "_QueryAvailablePerfMetric" - if ns0.QueryAvailablePerfMetricRequestType_Def not in ns0.QueryAvailablePerfMetric_Dec.__bases__: - bases = list(ns0.QueryAvailablePerfMetric_Dec.__bases__) - bases.insert(0, ns0.QueryAvailablePerfMetricRequestType_Def) - ns0.QueryAvailablePerfMetric_Dec.__bases__ = tuple(bases) - - ns0.QueryAvailablePerfMetricRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailablePerfMetric_Dec_Holder" - - class QueryAvailablePerfMetricResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryAvailablePerfMetricResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryAvailablePerfMetricResponse_Dec.schema - TClist = [GTD("urn:vim25","PerfMetricId",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryAvailablePerfMetricResponse") - kw["aname"] = "_QueryAvailablePerfMetricResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryAvailablePerfMetricResponse_Holder" - self.pyclass = Holder - - class QueryPerfCounter_Dec(ElementDeclaration): - literal = "QueryPerfCounter" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPerfCounter") - kw["aname"] = "_QueryPerfCounter" - if ns0.QueryPerfCounterRequestType_Def not in ns0.QueryPerfCounter_Dec.__bases__: - bases = list(ns0.QueryPerfCounter_Dec.__bases__) - bases.insert(0, ns0.QueryPerfCounterRequestType_Def) - ns0.QueryPerfCounter_Dec.__bases__ = tuple(bases) - - ns0.QueryPerfCounterRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfCounter_Dec_Holder" - - class QueryPerfCounterResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPerfCounterResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPerfCounterResponse_Dec.schema - TClist = [GTD("urn:vim25","PerfCounterInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPerfCounterResponse") - kw["aname"] = "_QueryPerfCounterResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryPerfCounterResponse_Holder" - self.pyclass = Holder - - class QueryPerfCounterByLevel_Dec(ElementDeclaration): - literal = "QueryPerfCounterByLevel" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPerfCounterByLevel") - kw["aname"] = "_QueryPerfCounterByLevel" - if ns0.QueryPerfCounterByLevelRequestType_Def not in ns0.QueryPerfCounterByLevel_Dec.__bases__: - bases = list(ns0.QueryPerfCounterByLevel_Dec.__bases__) - bases.insert(0, ns0.QueryPerfCounterByLevelRequestType_Def) - ns0.QueryPerfCounterByLevel_Dec.__bases__ = tuple(bases) - - ns0.QueryPerfCounterByLevelRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfCounterByLevel_Dec_Holder" - - class QueryPerfCounterByLevelResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPerfCounterByLevelResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPerfCounterByLevelResponse_Dec.schema - TClist = [GTD("urn:vim25","PerfCounterInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPerfCounterByLevelResponse") - kw["aname"] = "_QueryPerfCounterByLevelResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryPerfCounterByLevelResponse_Holder" - self.pyclass = Holder - - class QueryPerf_Dec(ElementDeclaration): - literal = "QueryPerf" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPerf") - kw["aname"] = "_QueryPerf" - if ns0.QueryPerfRequestType_Def not in ns0.QueryPerf_Dec.__bases__: - bases = list(ns0.QueryPerf_Dec.__bases__) - bases.insert(0, ns0.QueryPerfRequestType_Def) - ns0.QueryPerf_Dec.__bases__ = tuple(bases) - - ns0.QueryPerfRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPerf_Dec_Holder" - - class QueryPerfResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPerfResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPerfResponse_Dec.schema - TClist = [GTD("urn:vim25","PerfEntityMetricBase",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPerfResponse") - kw["aname"] = "_QueryPerfResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryPerfResponse_Holder" - self.pyclass = Holder - - class QueryPerfComposite_Dec(ElementDeclaration): - literal = "QueryPerfComposite" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPerfComposite") - kw["aname"] = "_QueryPerfComposite" - if ns0.QueryPerfCompositeRequestType_Def not in ns0.QueryPerfComposite_Dec.__bases__: - bases = list(ns0.QueryPerfComposite_Dec.__bases__) - bases.insert(0, ns0.QueryPerfCompositeRequestType_Def) - ns0.QueryPerfComposite_Dec.__bases__ = tuple(bases) - - ns0.QueryPerfCompositeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPerfComposite_Dec_Holder" - - class QueryPerfCompositeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPerfCompositeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPerfCompositeResponse_Dec.schema - TClist = [GTD("urn:vim25","PerfCompositeMetric",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPerfCompositeResponse") - kw["aname"] = "_QueryPerfCompositeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryPerfCompositeResponse_Holder" - self.pyclass = Holder - - class CreatePerfInterval_Dec(ElementDeclaration): - literal = "CreatePerfInterval" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreatePerfInterval") - kw["aname"] = "_CreatePerfInterval" - if ns0.CreatePerfIntervalRequestType_Def not in ns0.CreatePerfInterval_Dec.__bases__: - bases = list(ns0.CreatePerfInterval_Dec.__bases__) - bases.insert(0, ns0.CreatePerfIntervalRequestType_Def) - ns0.CreatePerfInterval_Dec.__bases__ = tuple(bases) - - ns0.CreatePerfIntervalRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreatePerfInterval_Dec_Holder" - - class CreatePerfIntervalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreatePerfIntervalResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreatePerfIntervalResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CreatePerfIntervalResponse") - kw["aname"] = "_CreatePerfIntervalResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CreatePerfIntervalResponse_Holder" - self.pyclass = Holder - - class RemovePerfInterval_Dec(ElementDeclaration): - literal = "RemovePerfInterval" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemovePerfInterval") - kw["aname"] = "_RemovePerfInterval" - if ns0.RemovePerfIntervalRequestType_Def not in ns0.RemovePerfInterval_Dec.__bases__: - bases = list(ns0.RemovePerfInterval_Dec.__bases__) - bases.insert(0, ns0.RemovePerfIntervalRequestType_Def) - ns0.RemovePerfInterval_Dec.__bases__ = tuple(bases) - - ns0.RemovePerfIntervalRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemovePerfInterval_Dec_Holder" - - class RemovePerfIntervalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemovePerfIntervalResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemovePerfIntervalResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemovePerfIntervalResponse") - kw["aname"] = "_RemovePerfIntervalResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemovePerfIntervalResponse_Holder" - self.pyclass = Holder - - class UpdatePerfInterval_Dec(ElementDeclaration): - literal = "UpdatePerfInterval" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdatePerfInterval") - kw["aname"] = "_UpdatePerfInterval" - if ns0.UpdatePerfIntervalRequestType_Def not in ns0.UpdatePerfInterval_Dec.__bases__: - bases = list(ns0.UpdatePerfInterval_Dec.__bases__) - bases.insert(0, ns0.UpdatePerfIntervalRequestType_Def) - ns0.UpdatePerfInterval_Dec.__bases__ = tuple(bases) - - ns0.UpdatePerfIntervalRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdatePerfInterval_Dec_Holder" - - class UpdatePerfIntervalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdatePerfIntervalResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdatePerfIntervalResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdatePerfIntervalResponse") - kw["aname"] = "_UpdatePerfIntervalResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdatePerfIntervalResponse_Holder" - self.pyclass = Holder - - class GetDatabaseSizeEstimate_Dec(ElementDeclaration): - literal = "GetDatabaseSizeEstimate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GetDatabaseSizeEstimate") - kw["aname"] = "_GetDatabaseSizeEstimate" - if ns0.GetDatabaseSizeEstimateRequestType_Def not in ns0.GetDatabaseSizeEstimate_Dec.__bases__: - bases = list(ns0.GetDatabaseSizeEstimate_Dec.__bases__) - bases.insert(0, ns0.GetDatabaseSizeEstimateRequestType_Def) - ns0.GetDatabaseSizeEstimate_Dec.__bases__ = tuple(bases) - - ns0.GetDatabaseSizeEstimateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GetDatabaseSizeEstimate_Dec_Holder" - - class GetDatabaseSizeEstimateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GetDatabaseSizeEstimateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GetDatabaseSizeEstimateResponse_Dec.schema - TClist = [GTD("urn:vim25","DatabaseSizeEstimate",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GetDatabaseSizeEstimateResponse") - kw["aname"] = "_GetDatabaseSizeEstimateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "GetDatabaseSizeEstimateResponse_Holder" - self.pyclass = Holder - - class UpdateConfig_Dec(ElementDeclaration): - literal = "UpdateConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateConfig") - kw["aname"] = "_UpdateConfig" - if ns0.UpdateConfigRequestType_Def not in ns0.UpdateConfig_Dec.__bases__: - bases = list(ns0.UpdateConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateConfigRequestType_Def) - ns0.UpdateConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateConfig_Dec_Holder" - - class UpdateConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateConfigResponse") - kw["aname"] = "_UpdateConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateConfigResponse_Holder" - self.pyclass = Holder - - class MoveIntoResourcePool_Dec(ElementDeclaration): - literal = "MoveIntoResourcePool" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveIntoResourcePool") - kw["aname"] = "_MoveIntoResourcePool" - if ns0.MoveIntoResourcePoolRequestType_Def not in ns0.MoveIntoResourcePool_Dec.__bases__: - bases = list(ns0.MoveIntoResourcePool_Dec.__bases__) - bases.insert(0, ns0.MoveIntoResourcePoolRequestType_Def) - ns0.MoveIntoResourcePool_Dec.__bases__ = tuple(bases) - - ns0.MoveIntoResourcePoolRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveIntoResourcePool_Dec_Holder" - - class MoveIntoResourcePoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveIntoResourcePoolResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveIntoResourcePoolResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MoveIntoResourcePoolResponse") - kw["aname"] = "_MoveIntoResourcePoolResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MoveIntoResourcePoolResponse_Holder" - self.pyclass = Holder - - class UpdateChildResourceConfiguration_Dec(ElementDeclaration): - literal = "UpdateChildResourceConfiguration" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateChildResourceConfiguration") - kw["aname"] = "_UpdateChildResourceConfiguration" - if ns0.UpdateChildResourceConfigurationRequestType_Def not in ns0.UpdateChildResourceConfiguration_Dec.__bases__: - bases = list(ns0.UpdateChildResourceConfiguration_Dec.__bases__) - bases.insert(0, ns0.UpdateChildResourceConfigurationRequestType_Def) - ns0.UpdateChildResourceConfiguration_Dec.__bases__ = tuple(bases) - - ns0.UpdateChildResourceConfigurationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateChildResourceConfiguration_Dec_Holder" - - class UpdateChildResourceConfigurationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateChildResourceConfigurationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateChildResourceConfigurationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateChildResourceConfigurationResponse") - kw["aname"] = "_UpdateChildResourceConfigurationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateChildResourceConfigurationResponse_Holder" - self.pyclass = Holder - - class CreateResourcePool_Dec(ElementDeclaration): - literal = "CreateResourcePool" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateResourcePool") - kw["aname"] = "_CreateResourcePool" - if ns0.CreateResourcePoolRequestType_Def not in ns0.CreateResourcePool_Dec.__bases__: - bases = list(ns0.CreateResourcePool_Dec.__bases__) - bases.insert(0, ns0.CreateResourcePoolRequestType_Def) - ns0.CreateResourcePool_Dec.__bases__ = tuple(bases) - - ns0.CreateResourcePoolRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateResourcePool_Dec_Holder" - - class CreateResourcePoolResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateResourcePoolResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateResourcePoolResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateResourcePoolResponse") - kw["aname"] = "_CreateResourcePoolResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateResourcePoolResponse_Holder" - self.pyclass = Holder - - class DestroyChildren_Dec(ElementDeclaration): - literal = "DestroyChildren" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestroyChildren") - kw["aname"] = "_DestroyChildren" - if ns0.DestroyChildrenRequestType_Def not in ns0.DestroyChildren_Dec.__bases__: - bases = list(ns0.DestroyChildren_Dec.__bases__) - bases.insert(0, ns0.DestroyChildrenRequestType_Def) - ns0.DestroyChildren_Dec.__bases__ = tuple(bases) - - ns0.DestroyChildrenRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestroyChildren_Dec_Holder" - - class DestroyChildrenResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyChildrenResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyChildrenResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyChildrenResponse") - kw["aname"] = "_DestroyChildrenResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyChildrenResponse_Holder" - self.pyclass = Holder - - class CreateVApp_Dec(ElementDeclaration): - literal = "CreateVApp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateVApp") - kw["aname"] = "_CreateVApp" - if ns0.CreateVAppRequestType_Def not in ns0.CreateVApp_Dec.__bases__: - bases = list(ns0.CreateVApp_Dec.__bases__) - bases.insert(0, ns0.CreateVAppRequestType_Def) - ns0.CreateVApp_Dec.__bases__ = tuple(bases) - - ns0.CreateVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateVApp_Dec_Holder" - - class CreateVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateVAppResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateVAppResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateVAppResponse") - kw["aname"] = "_CreateVAppResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateVAppResponse_Holder" - self.pyclass = Holder - - class CreateChildVM_Dec(ElementDeclaration): - literal = "CreateChildVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateChildVM") - kw["aname"] = "_CreateChildVM" - if ns0.CreateChildVMRequestType_Def not in ns0.CreateChildVM_Dec.__bases__: - bases = list(ns0.CreateChildVM_Dec.__bases__) - bases.insert(0, ns0.CreateChildVMRequestType_Def) - ns0.CreateChildVM_Dec.__bases__ = tuple(bases) - - ns0.CreateChildVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateChildVM_Dec_Holder" - - class CreateChildVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateChildVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateChildVMResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateChildVMResponse") - kw["aname"] = "_CreateChildVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateChildVMResponse_Holder" - self.pyclass = Holder - - class CreateChildVM_Task_Dec(ElementDeclaration): - literal = "CreateChildVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateChildVM_Task") - kw["aname"] = "_CreateChildVM_Task" - if ns0.CreateChildVMRequestType_Def not in ns0.CreateChildVM_Task_Dec.__bases__: - bases = list(ns0.CreateChildVM_Task_Dec.__bases__) - bases.insert(0, ns0.CreateChildVMRequestType_Def) - ns0.CreateChildVM_Task_Dec.__bases__ = tuple(bases) - - ns0.CreateChildVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateChildVM_Task_Dec_Holder" - - class CreateChildVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateChildVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateChildVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateChildVM_TaskResponse") - kw["aname"] = "_CreateChildVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateChildVM_TaskResponse_Holder" - self.pyclass = Holder - - class RegisterChildVM_Dec(ElementDeclaration): - literal = "RegisterChildVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RegisterChildVM") - kw["aname"] = "_RegisterChildVM" - if ns0.RegisterChildVMRequestType_Def not in ns0.RegisterChildVM_Dec.__bases__: - bases = list(ns0.RegisterChildVM_Dec.__bases__) - bases.insert(0, ns0.RegisterChildVMRequestType_Def) - ns0.RegisterChildVM_Dec.__bases__ = tuple(bases) - - ns0.RegisterChildVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RegisterChildVM_Dec_Holder" - - class RegisterChildVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RegisterChildVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RegisterChildVMResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RegisterChildVMResponse") - kw["aname"] = "_RegisterChildVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RegisterChildVMResponse_Holder" - self.pyclass = Holder - - class RegisterChildVM_Task_Dec(ElementDeclaration): - literal = "RegisterChildVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RegisterChildVM_Task") - kw["aname"] = "_RegisterChildVM_Task" - if ns0.RegisterChildVMRequestType_Def not in ns0.RegisterChildVM_Task_Dec.__bases__: - bases = list(ns0.RegisterChildVM_Task_Dec.__bases__) - bases.insert(0, ns0.RegisterChildVMRequestType_Def) - ns0.RegisterChildVM_Task_Dec.__bases__ = tuple(bases) - - ns0.RegisterChildVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RegisterChildVM_Task_Dec_Holder" - - class RegisterChildVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RegisterChildVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RegisterChildVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RegisterChildVM_TaskResponse") - kw["aname"] = "_RegisterChildVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RegisterChildVM_TaskResponse_Holder" - self.pyclass = Holder - - class ImportVApp_Dec(ElementDeclaration): - literal = "ImportVApp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ImportVApp") - kw["aname"] = "_ImportVApp" - if ns0.ImportVAppRequestType_Def not in ns0.ImportVApp_Dec.__bases__: - bases = list(ns0.ImportVApp_Dec.__bases__) - bases.insert(0, ns0.ImportVAppRequestType_Def) - ns0.ImportVApp_Dec.__bases__ = tuple(bases) - - ns0.ImportVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ImportVApp_Dec_Holder" - - class ImportVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ImportVAppResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ImportVAppResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ImportVAppResponse") - kw["aname"] = "_ImportVAppResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ImportVAppResponse_Holder" - self.pyclass = Holder - - class FindByUuid_Dec(ElementDeclaration): - literal = "FindByUuid" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindByUuid") - kw["aname"] = "_FindByUuid" - if ns0.FindByUuidRequestType_Def not in ns0.FindByUuid_Dec.__bases__: - bases = list(ns0.FindByUuid_Dec.__bases__) - bases.insert(0, ns0.FindByUuidRequestType_Def) - ns0.FindByUuid_Dec.__bases__ = tuple(bases) - - ns0.FindByUuidRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindByUuid_Dec_Holder" - - class FindByUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindByUuidResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindByUuidResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindByUuidResponse") - kw["aname"] = "_FindByUuidResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FindByUuidResponse_Holder" - self.pyclass = Holder - - class FindByDatastorePath_Dec(ElementDeclaration): - literal = "FindByDatastorePath" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindByDatastorePath") - kw["aname"] = "_FindByDatastorePath" - if ns0.FindByDatastorePathRequestType_Def not in ns0.FindByDatastorePath_Dec.__bases__: - bases = list(ns0.FindByDatastorePath_Dec.__bases__) - bases.insert(0, ns0.FindByDatastorePathRequestType_Def) - ns0.FindByDatastorePath_Dec.__bases__ = tuple(bases) - - ns0.FindByDatastorePathRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindByDatastorePath_Dec_Holder" - - class FindByDatastorePathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindByDatastorePathResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindByDatastorePathResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindByDatastorePathResponse") - kw["aname"] = "_FindByDatastorePathResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FindByDatastorePathResponse_Holder" - self.pyclass = Holder - - class FindByDnsName_Dec(ElementDeclaration): - literal = "FindByDnsName" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindByDnsName") - kw["aname"] = "_FindByDnsName" - if ns0.FindByDnsNameRequestType_Def not in ns0.FindByDnsName_Dec.__bases__: - bases = list(ns0.FindByDnsName_Dec.__bases__) - bases.insert(0, ns0.FindByDnsNameRequestType_Def) - ns0.FindByDnsName_Dec.__bases__ = tuple(bases) - - ns0.FindByDnsNameRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindByDnsName_Dec_Holder" - - class FindByDnsNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindByDnsNameResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindByDnsNameResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindByDnsNameResponse") - kw["aname"] = "_FindByDnsNameResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FindByDnsNameResponse_Holder" - self.pyclass = Holder - - class FindByIp_Dec(ElementDeclaration): - literal = "FindByIp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindByIp") - kw["aname"] = "_FindByIp" - if ns0.FindByIpRequestType_Def not in ns0.FindByIp_Dec.__bases__: - bases = list(ns0.FindByIp_Dec.__bases__) - bases.insert(0, ns0.FindByIpRequestType_Def) - ns0.FindByIp_Dec.__bases__ = tuple(bases) - - ns0.FindByIpRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindByIp_Dec_Holder" - - class FindByIpResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindByIpResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindByIpResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindByIpResponse") - kw["aname"] = "_FindByIpResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FindByIpResponse_Holder" - self.pyclass = Holder - - class FindByInventoryPath_Dec(ElementDeclaration): - literal = "FindByInventoryPath" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindByInventoryPath") - kw["aname"] = "_FindByInventoryPath" - if ns0.FindByInventoryPathRequestType_Def not in ns0.FindByInventoryPath_Dec.__bases__: - bases = list(ns0.FindByInventoryPath_Dec.__bases__) - bases.insert(0, ns0.FindByInventoryPathRequestType_Def) - ns0.FindByInventoryPath_Dec.__bases__ = tuple(bases) - - ns0.FindByInventoryPathRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindByInventoryPath_Dec_Holder" - - class FindByInventoryPathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindByInventoryPathResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindByInventoryPathResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindByInventoryPathResponse") - kw["aname"] = "_FindByInventoryPathResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FindByInventoryPathResponse_Holder" - self.pyclass = Holder - - class FindChild_Dec(ElementDeclaration): - literal = "FindChild" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindChild") - kw["aname"] = "_FindChild" - if ns0.FindChildRequestType_Def not in ns0.FindChild_Dec.__bases__: - bases = list(ns0.FindChild_Dec.__bases__) - bases.insert(0, ns0.FindChildRequestType_Def) - ns0.FindChild_Dec.__bases__ = tuple(bases) - - ns0.FindChildRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindChild_Dec_Holder" - - class FindChildResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindChildResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindChildResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindChildResponse") - kw["aname"] = "_FindChildResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FindChildResponse_Holder" - self.pyclass = Holder - - class FindAllByUuid_Dec(ElementDeclaration): - literal = "FindAllByUuid" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindAllByUuid") - kw["aname"] = "_FindAllByUuid" - if ns0.FindAllByUuidRequestType_Def not in ns0.FindAllByUuid_Dec.__bases__: - bases = list(ns0.FindAllByUuid_Dec.__bases__) - bases.insert(0, ns0.FindAllByUuidRequestType_Def) - ns0.FindAllByUuid_Dec.__bases__ = tuple(bases) - - ns0.FindAllByUuidRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindAllByUuid_Dec_Holder" - - class FindAllByUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindAllByUuidResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindAllByUuidResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindAllByUuidResponse") - kw["aname"] = "_FindAllByUuidResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "FindAllByUuidResponse_Holder" - self.pyclass = Holder - - class FindAllByDnsName_Dec(ElementDeclaration): - literal = "FindAllByDnsName" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindAllByDnsName") - kw["aname"] = "_FindAllByDnsName" - if ns0.FindAllByDnsNameRequestType_Def not in ns0.FindAllByDnsName_Dec.__bases__: - bases = list(ns0.FindAllByDnsName_Dec.__bases__) - bases.insert(0, ns0.FindAllByDnsNameRequestType_Def) - ns0.FindAllByDnsName_Dec.__bases__ = tuple(bases) - - ns0.FindAllByDnsNameRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindAllByDnsName_Dec_Holder" - - class FindAllByDnsNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindAllByDnsNameResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindAllByDnsNameResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindAllByDnsNameResponse") - kw["aname"] = "_FindAllByDnsNameResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "FindAllByDnsNameResponse_Holder" - self.pyclass = Holder - - class FindAllByIp_Dec(ElementDeclaration): - literal = "FindAllByIp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FindAllByIp") - kw["aname"] = "_FindAllByIp" - if ns0.FindAllByIpRequestType_Def not in ns0.FindAllByIp_Dec.__bases__: - bases = list(ns0.FindAllByIp_Dec.__bases__) - bases.insert(0, ns0.FindAllByIpRequestType_Def) - ns0.FindAllByIp_Dec.__bases__ = tuple(bases) - - ns0.FindAllByIpRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FindAllByIp_Dec_Holder" - - class FindAllByIpResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FindAllByIpResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FindAllByIpResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FindAllByIpResponse") - kw["aname"] = "_FindAllByIpResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "FindAllByIpResponse_Holder" - self.pyclass = Holder - - class CurrentTime_Dec(ElementDeclaration): - literal = "CurrentTime" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CurrentTime") - kw["aname"] = "_CurrentTime" - if ns0.CurrentTimeRequestType_Def not in ns0.CurrentTime_Dec.__bases__: - bases = list(ns0.CurrentTime_Dec.__bases__) - bases.insert(0, ns0.CurrentTimeRequestType_Def) - ns0.CurrentTime_Dec.__bases__ = tuple(bases) - - ns0.CurrentTimeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CurrentTime_Dec_Holder" - - class CurrentTimeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CurrentTimeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CurrentTimeResponse_Dec.schema - TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CurrentTimeResponse") - kw["aname"] = "_CurrentTimeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CurrentTimeResponse_Holder" - self.pyclass = Holder - - class RetrieveServiceContent_Dec(ElementDeclaration): - literal = "RetrieveServiceContent" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveServiceContent") - kw["aname"] = "_RetrieveServiceContent" - if ns0.RetrieveServiceContentRequestType_Def not in ns0.RetrieveServiceContent_Dec.__bases__: - bases = list(ns0.RetrieveServiceContent_Dec.__bases__) - bases.insert(0, ns0.RetrieveServiceContentRequestType_Def) - ns0.RetrieveServiceContent_Dec.__bases__ = tuple(bases) - - ns0.RetrieveServiceContentRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveServiceContent_Dec_Holder" - - class RetrieveServiceContentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveServiceContentResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveServiceContentResponse_Dec.schema - TClist = [GTD("urn:vim25","ServiceContent",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveServiceContentResponse") - kw["aname"] = "_RetrieveServiceContentResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RetrieveServiceContentResponse_Holder" - self.pyclass = Holder - - class ValidateMigration_Dec(ElementDeclaration): - literal = "ValidateMigration" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ValidateMigration") - kw["aname"] = "_ValidateMigration" - if ns0.ValidateMigrationRequestType_Def not in ns0.ValidateMigration_Dec.__bases__: - bases = list(ns0.ValidateMigration_Dec.__bases__) - bases.insert(0, ns0.ValidateMigrationRequestType_Def) - ns0.ValidateMigration_Dec.__bases__ = tuple(bases) - - ns0.ValidateMigrationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ValidateMigration_Dec_Holder" - - class ValidateMigrationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ValidateMigrationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ValidateMigrationResponse_Dec.schema - TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ValidateMigrationResponse") - kw["aname"] = "_ValidateMigrationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ValidateMigrationResponse_Holder" - self.pyclass = Holder - - class QueryVMotionCompatibility_Dec(ElementDeclaration): - literal = "QueryVMotionCompatibility" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVMotionCompatibility") - kw["aname"] = "_QueryVMotionCompatibility" - if ns0.QueryVMotionCompatibilityRequestType_Def not in ns0.QueryVMotionCompatibility_Dec.__bases__: - bases = list(ns0.QueryVMotionCompatibility_Dec.__bases__) - bases.insert(0, ns0.QueryVMotionCompatibilityRequestType_Def) - ns0.QueryVMotionCompatibility_Dec.__bases__ = tuple(bases) - - ns0.QueryVMotionCompatibilityRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVMotionCompatibility_Dec_Holder" - - class QueryVMotionCompatibilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVMotionCompatibilityResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVMotionCompatibilityResponse_Dec.schema - TClist = [GTD("urn:vim25","HostVMotionCompatibility",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityResponse") - kw["aname"] = "_QueryVMotionCompatibilityResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryVMotionCompatibilityResponse_Holder" - self.pyclass = Holder - - class RetrieveProductComponents_Dec(ElementDeclaration): - literal = "RetrieveProductComponents" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveProductComponents") - kw["aname"] = "_RetrieveProductComponents" - if ns0.RetrieveProductComponentsRequestType_Def not in ns0.RetrieveProductComponents_Dec.__bases__: - bases = list(ns0.RetrieveProductComponents_Dec.__bases__) - bases.insert(0, ns0.RetrieveProductComponentsRequestType_Def) - ns0.RetrieveProductComponents_Dec.__bases__ = tuple(bases) - - ns0.RetrieveProductComponentsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveProductComponents_Dec_Holder" - - class RetrieveProductComponentsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveProductComponentsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveProductComponentsResponse_Dec.schema - TClist = [GTD("urn:vim25","ProductComponentInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveProductComponentsResponse") - kw["aname"] = "_RetrieveProductComponentsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveProductComponentsResponse_Holder" - self.pyclass = Holder - - class UpdateServiceMessage_Dec(ElementDeclaration): - literal = "UpdateServiceMessage" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateServiceMessage") - kw["aname"] = "_UpdateServiceMessage" - if ns0.UpdateServiceMessageRequestType_Def not in ns0.UpdateServiceMessage_Dec.__bases__: - bases = list(ns0.UpdateServiceMessage_Dec.__bases__) - bases.insert(0, ns0.UpdateServiceMessageRequestType_Def) - ns0.UpdateServiceMessage_Dec.__bases__ = tuple(bases) - - ns0.UpdateServiceMessageRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateServiceMessage_Dec_Holder" - - class UpdateServiceMessageResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateServiceMessageResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateServiceMessageResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateServiceMessageResponse") - kw["aname"] = "_UpdateServiceMessageResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateServiceMessageResponse_Holder" - self.pyclass = Holder - - class Login_Dec(ElementDeclaration): - literal = "Login" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Login") - kw["aname"] = "_Login" - if ns0.LoginRequestType_Def not in ns0.Login_Dec.__bases__: - bases = list(ns0.Login_Dec.__bases__) - bases.insert(0, ns0.LoginRequestType_Def) - ns0.Login_Dec.__bases__ = tuple(bases) - - ns0.LoginRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Login_Dec_Holder" - - class LoginResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "LoginResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.LoginResponse_Dec.schema - TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","LoginResponse") - kw["aname"] = "_LoginResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "LoginResponse_Holder" - self.pyclass = Holder - - class LoginBySSPI_Dec(ElementDeclaration): - literal = "LoginBySSPI" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LoginBySSPI") - kw["aname"] = "_LoginBySSPI" - if ns0.LoginBySSPIRequestType_Def not in ns0.LoginBySSPI_Dec.__bases__: - bases = list(ns0.LoginBySSPI_Dec.__bases__) - bases.insert(0, ns0.LoginBySSPIRequestType_Def) - ns0.LoginBySSPI_Dec.__bases__ = tuple(bases) - - ns0.LoginBySSPIRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LoginBySSPI_Dec_Holder" - - class LoginBySSPIResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "LoginBySSPIResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.LoginBySSPIResponse_Dec.schema - TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","LoginBySSPIResponse") - kw["aname"] = "_LoginBySSPIResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "LoginBySSPIResponse_Holder" - self.pyclass = Holder - - class Logout_Dec(ElementDeclaration): - literal = "Logout" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Logout") - kw["aname"] = "_Logout" - if ns0.LogoutRequestType_Def not in ns0.Logout_Dec.__bases__: - bases = list(ns0.Logout_Dec.__bases__) - bases.insert(0, ns0.LogoutRequestType_Def) - ns0.Logout_Dec.__bases__ = tuple(bases) - - ns0.LogoutRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Logout_Dec_Holder" - - class LogoutResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "LogoutResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.LogoutResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","LogoutResponse") - kw["aname"] = "_LogoutResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "LogoutResponse_Holder" - self.pyclass = Holder - - class AcquireLocalTicket_Dec(ElementDeclaration): - literal = "AcquireLocalTicket" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AcquireLocalTicket") - kw["aname"] = "_AcquireLocalTicket" - if ns0.AcquireLocalTicketRequestType_Def not in ns0.AcquireLocalTicket_Dec.__bases__: - bases = list(ns0.AcquireLocalTicket_Dec.__bases__) - bases.insert(0, ns0.AcquireLocalTicketRequestType_Def) - ns0.AcquireLocalTicket_Dec.__bases__ = tuple(bases) - - ns0.AcquireLocalTicketRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AcquireLocalTicket_Dec_Holder" - - class AcquireLocalTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AcquireLocalTicketResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AcquireLocalTicketResponse_Dec.schema - TClist = [GTD("urn:vim25","SessionManagerLocalTicket",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AcquireLocalTicketResponse") - kw["aname"] = "_AcquireLocalTicketResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AcquireLocalTicketResponse_Holder" - self.pyclass = Holder - - class TerminateSession_Dec(ElementDeclaration): - literal = "TerminateSession" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TerminateSession") - kw["aname"] = "_TerminateSession" - if ns0.TerminateSessionRequestType_Def not in ns0.TerminateSession_Dec.__bases__: - bases = list(ns0.TerminateSession_Dec.__bases__) - bases.insert(0, ns0.TerminateSessionRequestType_Def) - ns0.TerminateSession_Dec.__bases__ = tuple(bases) - - ns0.TerminateSessionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TerminateSession_Dec_Holder" - - class TerminateSessionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "TerminateSessionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.TerminateSessionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","TerminateSessionResponse") - kw["aname"] = "_TerminateSessionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "TerminateSessionResponse_Holder" - self.pyclass = Holder - - class SetLocale_Dec(ElementDeclaration): - literal = "SetLocale" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetLocale") - kw["aname"] = "_SetLocale" - if ns0.SetLocaleRequestType_Def not in ns0.SetLocale_Dec.__bases__: - bases = list(ns0.SetLocale_Dec.__bases__) - bases.insert(0, ns0.SetLocaleRequestType_Def) - ns0.SetLocale_Dec.__bases__ = tuple(bases) - - ns0.SetLocaleRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetLocale_Dec_Holder" - - class SetLocaleResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetLocaleResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetLocaleResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetLocaleResponse") - kw["aname"] = "_SetLocaleResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetLocaleResponse_Holder" - self.pyclass = Holder - - class LoginExtensionBySubjectName_Dec(ElementDeclaration): - literal = "LoginExtensionBySubjectName" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LoginExtensionBySubjectName") - kw["aname"] = "_LoginExtensionBySubjectName" - if ns0.LoginExtensionBySubjectNameRequestType_Def not in ns0.LoginExtensionBySubjectName_Dec.__bases__: - bases = list(ns0.LoginExtensionBySubjectName_Dec.__bases__) - bases.insert(0, ns0.LoginExtensionBySubjectNameRequestType_Def) - ns0.LoginExtensionBySubjectName_Dec.__bases__ = tuple(bases) - - ns0.LoginExtensionBySubjectNameRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LoginExtensionBySubjectName_Dec_Holder" - - class LoginExtensionBySubjectNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "LoginExtensionBySubjectNameResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.LoginExtensionBySubjectNameResponse_Dec.schema - TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","LoginExtensionBySubjectNameResponse") - kw["aname"] = "_LoginExtensionBySubjectNameResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "LoginExtensionBySubjectNameResponse_Holder" - self.pyclass = Holder - - class ImpersonateUser_Dec(ElementDeclaration): - literal = "ImpersonateUser" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ImpersonateUser") - kw["aname"] = "_ImpersonateUser" - if ns0.ImpersonateUserRequestType_Def not in ns0.ImpersonateUser_Dec.__bases__: - bases = list(ns0.ImpersonateUser_Dec.__bases__) - bases.insert(0, ns0.ImpersonateUserRequestType_Def) - ns0.ImpersonateUser_Dec.__bases__ = tuple(bases) - - ns0.ImpersonateUserRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ImpersonateUser_Dec_Holder" - - class ImpersonateUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ImpersonateUserResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ImpersonateUserResponse_Dec.schema - TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ImpersonateUserResponse") - kw["aname"] = "_ImpersonateUserResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ImpersonateUserResponse_Holder" - self.pyclass = Holder - - class SessionIsActive_Dec(ElementDeclaration): - literal = "SessionIsActive" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SessionIsActive") - kw["aname"] = "_SessionIsActive" - if ns0.SessionIsActiveRequestType_Def not in ns0.SessionIsActive_Dec.__bases__: - bases = list(ns0.SessionIsActive_Dec.__bases__) - bases.insert(0, ns0.SessionIsActiveRequestType_Def) - ns0.SessionIsActive_Dec.__bases__ = tuple(bases) - - ns0.SessionIsActiveRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SessionIsActive_Dec_Holder" - - class SessionIsActiveResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SessionIsActiveResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SessionIsActiveResponse_Dec.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","SessionIsActiveResponse") - kw["aname"] = "_SessionIsActiveResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "SessionIsActiveResponse_Holder" - self.pyclass = Holder - - class AcquireCloneTicket_Dec(ElementDeclaration): - literal = "AcquireCloneTicket" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AcquireCloneTicket") - kw["aname"] = "_AcquireCloneTicket" - if ns0.AcquireCloneTicketRequestType_Def not in ns0.AcquireCloneTicket_Dec.__bases__: - bases = list(ns0.AcquireCloneTicket_Dec.__bases__) - bases.insert(0, ns0.AcquireCloneTicketRequestType_Def) - ns0.AcquireCloneTicket_Dec.__bases__ = tuple(bases) - - ns0.AcquireCloneTicketRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AcquireCloneTicket_Dec_Holder" - - class AcquireCloneTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AcquireCloneTicketResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AcquireCloneTicketResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AcquireCloneTicketResponse") - kw["aname"] = "_AcquireCloneTicketResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AcquireCloneTicketResponse_Holder" - self.pyclass = Holder - - class CloneSession_Dec(ElementDeclaration): - literal = "CloneSession" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CloneSession") - kw["aname"] = "_CloneSession" - if ns0.CloneSessionRequestType_Def not in ns0.CloneSession_Dec.__bases__: - bases = list(ns0.CloneSession_Dec.__bases__) - bases.insert(0, ns0.CloneSessionRequestType_Def) - ns0.CloneSession_Dec.__bases__ = tuple(bases) - - ns0.CloneSessionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CloneSession_Dec_Holder" - - class CloneSessionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CloneSessionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CloneSessionResponse_Dec.schema - TClist = [GTD("urn:vim25","UserSession",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CloneSessionResponse") - kw["aname"] = "_CloneSessionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CloneSessionResponse_Holder" - self.pyclass = Holder - - class CancelTask_Dec(ElementDeclaration): - literal = "CancelTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CancelTask") - kw["aname"] = "_CancelTask" - if ns0.CancelTaskRequestType_Def not in ns0.CancelTask_Dec.__bases__: - bases = list(ns0.CancelTask_Dec.__bases__) - bases.insert(0, ns0.CancelTaskRequestType_Def) - ns0.CancelTask_Dec.__bases__ = tuple(bases) - - ns0.CancelTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CancelTask_Dec_Holder" - - class CancelTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CancelTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CancelTaskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CancelTaskResponse") - kw["aname"] = "_CancelTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CancelTaskResponse_Holder" - self.pyclass = Holder - - class UpdateProgress_Dec(ElementDeclaration): - literal = "UpdateProgress" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateProgress") - kw["aname"] = "_UpdateProgress" - if ns0.UpdateProgressRequestType_Def not in ns0.UpdateProgress_Dec.__bases__: - bases = list(ns0.UpdateProgress_Dec.__bases__) - bases.insert(0, ns0.UpdateProgressRequestType_Def) - ns0.UpdateProgress_Dec.__bases__ = tuple(bases) - - ns0.UpdateProgressRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateProgress_Dec_Holder" - - class UpdateProgressResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateProgressResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateProgressResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateProgressResponse") - kw["aname"] = "_UpdateProgressResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateProgressResponse_Holder" - self.pyclass = Holder - - class SetTaskState_Dec(ElementDeclaration): - literal = "SetTaskState" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetTaskState") - kw["aname"] = "_SetTaskState" - if ns0.SetTaskStateRequestType_Def not in ns0.SetTaskState_Dec.__bases__: - bases = list(ns0.SetTaskState_Dec.__bases__) - bases.insert(0, ns0.SetTaskStateRequestType_Def) - ns0.SetTaskState_Dec.__bases__ = tuple(bases) - - ns0.SetTaskStateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetTaskState_Dec_Holder" - - class SetTaskStateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetTaskStateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetTaskStateResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetTaskStateResponse") - kw["aname"] = "_SetTaskStateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetTaskStateResponse_Holder" - self.pyclass = Holder - - class SetTaskDescription_Dec(ElementDeclaration): - literal = "SetTaskDescription" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetTaskDescription") - kw["aname"] = "_SetTaskDescription" - if ns0.SetTaskDescriptionRequestType_Def not in ns0.SetTaskDescription_Dec.__bases__: - bases = list(ns0.SetTaskDescription_Dec.__bases__) - bases.insert(0, ns0.SetTaskDescriptionRequestType_Def) - ns0.SetTaskDescription_Dec.__bases__ = tuple(bases) - - ns0.SetTaskDescriptionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetTaskDescription_Dec_Holder" - - class SetTaskDescriptionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetTaskDescriptionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetTaskDescriptionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetTaskDescriptionResponse") - kw["aname"] = "_SetTaskDescriptionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetTaskDescriptionResponse_Holder" - self.pyclass = Holder - - class ReadNextTasks_Dec(ElementDeclaration): - literal = "ReadNextTasks" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReadNextTasks") - kw["aname"] = "_ReadNextTasks" - if ns0.ReadNextTasksRequestType_Def not in ns0.ReadNextTasks_Dec.__bases__: - bases = list(ns0.ReadNextTasks_Dec.__bases__) - bases.insert(0, ns0.ReadNextTasksRequestType_Def) - ns0.ReadNextTasks_Dec.__bases__ = tuple(bases) - - ns0.ReadNextTasksRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReadNextTasks_Dec_Holder" - - class ReadNextTasksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReadNextTasksResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReadNextTasksResponse_Dec.schema - TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReadNextTasksResponse") - kw["aname"] = "_ReadNextTasksResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ReadNextTasksResponse_Holder" - self.pyclass = Holder - - class ReadPreviousTasks_Dec(ElementDeclaration): - literal = "ReadPreviousTasks" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReadPreviousTasks") - kw["aname"] = "_ReadPreviousTasks" - if ns0.ReadPreviousTasksRequestType_Def not in ns0.ReadPreviousTasks_Dec.__bases__: - bases = list(ns0.ReadPreviousTasks_Dec.__bases__) - bases.insert(0, ns0.ReadPreviousTasksRequestType_Def) - ns0.ReadPreviousTasks_Dec.__bases__ = tuple(bases) - - ns0.ReadPreviousTasksRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReadPreviousTasks_Dec_Holder" - - class ReadPreviousTasksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReadPreviousTasksResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReadPreviousTasksResponse_Dec.schema - TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReadPreviousTasksResponse") - kw["aname"] = "_ReadPreviousTasksResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ReadPreviousTasksResponse_Holder" - self.pyclass = Holder - - class CreateCollectorForTasks_Dec(ElementDeclaration): - literal = "CreateCollectorForTasks" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateCollectorForTasks") - kw["aname"] = "_CreateCollectorForTasks" - if ns0.CreateCollectorForTasksRequestType_Def not in ns0.CreateCollectorForTasks_Dec.__bases__: - bases = list(ns0.CreateCollectorForTasks_Dec.__bases__) - bases.insert(0, ns0.CreateCollectorForTasksRequestType_Def) - ns0.CreateCollectorForTasks_Dec.__bases__ = tuple(bases) - - ns0.CreateCollectorForTasksRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateCollectorForTasks_Dec_Holder" - - class CreateCollectorForTasksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateCollectorForTasksResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateCollectorForTasksResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateCollectorForTasksResponse") - kw["aname"] = "_CreateCollectorForTasksResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateCollectorForTasksResponse_Holder" - self.pyclass = Holder - - class CreateTask_Dec(ElementDeclaration): - literal = "CreateTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateTask") - kw["aname"] = "_CreateTask" - if ns0.CreateTaskRequestType_Def not in ns0.CreateTask_Dec.__bases__: - bases = list(ns0.CreateTask_Dec.__bases__) - bases.insert(0, ns0.CreateTaskRequestType_Def) - ns0.CreateTask_Dec.__bases__ = tuple(bases) - - ns0.CreateTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateTask_Dec_Holder" - - class CreateTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateTaskResponse_Dec.schema - TClist = [GTD("urn:vim25","TaskInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateTaskResponse") - kw["aname"] = "_CreateTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateTaskResponse_Holder" - self.pyclass = Holder - - class RetrieveUserGroups_Dec(ElementDeclaration): - literal = "RetrieveUserGroups" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveUserGroups") - kw["aname"] = "_RetrieveUserGroups" - if ns0.RetrieveUserGroupsRequestType_Def not in ns0.RetrieveUserGroups_Dec.__bases__: - bases = list(ns0.RetrieveUserGroups_Dec.__bases__) - bases.insert(0, ns0.RetrieveUserGroupsRequestType_Def) - ns0.RetrieveUserGroups_Dec.__bases__ = tuple(bases) - - ns0.RetrieveUserGroupsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveUserGroups_Dec_Holder" - - class RetrieveUserGroupsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveUserGroupsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveUserGroupsResponse_Dec.schema - TClist = [GTD("urn:vim25","UserSearchResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveUserGroupsResponse") - kw["aname"] = "_RetrieveUserGroupsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveUserGroupsResponse_Holder" - self.pyclass = Holder - - class UpdateVAppConfig_Dec(ElementDeclaration): - literal = "UpdateVAppConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateVAppConfig") - kw["aname"] = "_UpdateVAppConfig" - if ns0.UpdateVAppConfigRequestType_Def not in ns0.UpdateVAppConfig_Dec.__bases__: - bases = list(ns0.UpdateVAppConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateVAppConfigRequestType_Def) - ns0.UpdateVAppConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateVAppConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateVAppConfig_Dec_Holder" - - class UpdateVAppConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateVAppConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateVAppConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateVAppConfigResponse") - kw["aname"] = "_UpdateVAppConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateVAppConfigResponse_Holder" - self.pyclass = Holder - - class CloneVApp_Dec(ElementDeclaration): - literal = "CloneVApp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CloneVApp") - kw["aname"] = "_CloneVApp" - if ns0.CloneVAppRequestType_Def not in ns0.CloneVApp_Dec.__bases__: - bases = list(ns0.CloneVApp_Dec.__bases__) - bases.insert(0, ns0.CloneVAppRequestType_Def) - ns0.CloneVApp_Dec.__bases__ = tuple(bases) - - ns0.CloneVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CloneVApp_Dec_Holder" - - class CloneVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CloneVAppResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CloneVAppResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CloneVAppResponse") - kw["aname"] = "_CloneVAppResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CloneVAppResponse_Holder" - self.pyclass = Holder - - class CloneVApp_Task_Dec(ElementDeclaration): - literal = "CloneVApp_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CloneVApp_Task") - kw["aname"] = "_CloneVApp_Task" - if ns0.CloneVAppRequestType_Def not in ns0.CloneVApp_Task_Dec.__bases__: - bases = list(ns0.CloneVApp_Task_Dec.__bases__) - bases.insert(0, ns0.CloneVAppRequestType_Def) - ns0.CloneVApp_Task_Dec.__bases__ = tuple(bases) - - ns0.CloneVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CloneVApp_Task_Dec_Holder" - - class CloneVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CloneVApp_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CloneVApp_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CloneVApp_TaskResponse") - kw["aname"] = "_CloneVApp_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CloneVApp_TaskResponse_Holder" - self.pyclass = Holder - - class ExportVApp_Dec(ElementDeclaration): - literal = "ExportVApp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExportVApp") - kw["aname"] = "_ExportVApp" - if ns0.ExportVAppRequestType_Def not in ns0.ExportVApp_Dec.__bases__: - bases = list(ns0.ExportVApp_Dec.__bases__) - bases.insert(0, ns0.ExportVAppRequestType_Def) - ns0.ExportVApp_Dec.__bases__ = tuple(bases) - - ns0.ExportVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExportVApp_Dec_Holder" - - class ExportVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExportVAppResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExportVAppResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ExportVAppResponse") - kw["aname"] = "_ExportVAppResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ExportVAppResponse_Holder" - self.pyclass = Holder - - class PowerOnVApp_Dec(ElementDeclaration): - literal = "PowerOnVApp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnVApp") - kw["aname"] = "_PowerOnVApp" - if ns0.PowerOnVAppRequestType_Def not in ns0.PowerOnVApp_Dec.__bases__: - bases = list(ns0.PowerOnVApp_Dec.__bases__) - bases.insert(0, ns0.PowerOnVAppRequestType_Def) - ns0.PowerOnVApp_Dec.__bases__ = tuple(bases) - - ns0.PowerOnVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVApp_Dec_Holder" - - class PowerOnVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOnVAppResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOnVAppResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PowerOnVAppResponse") - kw["aname"] = "_PowerOnVAppResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PowerOnVAppResponse_Holder" - self.pyclass = Holder - - class PowerOnVApp_Task_Dec(ElementDeclaration): - literal = "PowerOnVApp_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnVApp_Task") - kw["aname"] = "_PowerOnVApp_Task" - if ns0.PowerOnVAppRequestType_Def not in ns0.PowerOnVApp_Task_Dec.__bases__: - bases = list(ns0.PowerOnVApp_Task_Dec.__bases__) - bases.insert(0, ns0.PowerOnVAppRequestType_Def) - ns0.PowerOnVApp_Task_Dec.__bases__ = tuple(bases) - - ns0.PowerOnVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVApp_Task_Dec_Holder" - - class PowerOnVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOnVApp_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOnVApp_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerOnVApp_TaskResponse") - kw["aname"] = "_PowerOnVApp_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerOnVApp_TaskResponse_Holder" - self.pyclass = Holder - - class PowerOffVApp_Dec(ElementDeclaration): - literal = "PowerOffVApp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOffVApp") - kw["aname"] = "_PowerOffVApp" - if ns0.PowerOffVAppRequestType_Def not in ns0.PowerOffVApp_Dec.__bases__: - bases = list(ns0.PowerOffVApp_Dec.__bases__) - bases.insert(0, ns0.PowerOffVAppRequestType_Def) - ns0.PowerOffVApp_Dec.__bases__ = tuple(bases) - - ns0.PowerOffVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVApp_Dec_Holder" - - class PowerOffVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOffVAppResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOffVAppResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PowerOffVAppResponse") - kw["aname"] = "_PowerOffVAppResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PowerOffVAppResponse_Holder" - self.pyclass = Holder - - class PowerOffVApp_Task_Dec(ElementDeclaration): - literal = "PowerOffVApp_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOffVApp_Task") - kw["aname"] = "_PowerOffVApp_Task" - if ns0.PowerOffVAppRequestType_Def not in ns0.PowerOffVApp_Task_Dec.__bases__: - bases = list(ns0.PowerOffVApp_Task_Dec.__bases__) - bases.insert(0, ns0.PowerOffVAppRequestType_Def) - ns0.PowerOffVApp_Task_Dec.__bases__ = tuple(bases) - - ns0.PowerOffVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVApp_Task_Dec_Holder" - - class PowerOffVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOffVApp_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOffVApp_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerOffVApp_TaskResponse") - kw["aname"] = "_PowerOffVApp_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerOffVApp_TaskResponse_Holder" - self.pyclass = Holder - - class unregisterVApp_Dec(ElementDeclaration): - literal = "unregisterVApp" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","unregisterVApp") - kw["aname"] = "_unregisterVApp" - if ns0.unregisterVAppRequestType_Def not in ns0.unregisterVApp_Dec.__bases__: - bases = list(ns0.unregisterVApp_Dec.__bases__) - bases.insert(0, ns0.unregisterVAppRequestType_Def) - ns0.unregisterVApp_Dec.__bases__ = tuple(bases) - - ns0.unregisterVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "unregisterVApp_Dec_Holder" - - class unregisterVAppResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "unregisterVAppResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.unregisterVAppResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","unregisterVAppResponse") - kw["aname"] = "_unregisterVAppResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "unregisterVAppResponse_Holder" - self.pyclass = Holder - - class unregisterVApp_Task_Dec(ElementDeclaration): - literal = "unregisterVApp_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","unregisterVApp_Task") - kw["aname"] = "_unregisterVApp_Task" - if ns0.unregisterVAppRequestType_Def not in ns0.unregisterVApp_Task_Dec.__bases__: - bases = list(ns0.unregisterVApp_Task_Dec.__bases__) - bases.insert(0, ns0.unregisterVAppRequestType_Def) - ns0.unregisterVApp_Task_Dec.__bases__ = tuple(bases) - - ns0.unregisterVAppRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "unregisterVApp_Task_Dec_Holder" - - class unregisterVApp_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "unregisterVApp_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.unregisterVApp_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","unregisterVApp_TaskResponse") - kw["aname"] = "_unregisterVApp_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "unregisterVApp_TaskResponse_Holder" - self.pyclass = Holder - - class CreateVirtualDisk_Dec(ElementDeclaration): - literal = "CreateVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateVirtualDisk") - kw["aname"] = "_CreateVirtualDisk" - if ns0.CreateVirtualDiskRequestType_Def not in ns0.CreateVirtualDisk_Dec.__bases__: - bases = list(ns0.CreateVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.CreateVirtualDiskRequestType_Def) - ns0.CreateVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.CreateVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateVirtualDisk_Dec_Holder" - - class CreateVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateVirtualDiskResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateVirtualDiskResponse") - kw["aname"] = "_CreateVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateVirtualDiskResponse_Holder" - self.pyclass = Holder - - class CreateVirtualDisk_Task_Dec(ElementDeclaration): - literal = "CreateVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateVirtualDisk_Task") - kw["aname"] = "_CreateVirtualDisk_Task" - if ns0.CreateVirtualDiskRequestType_Def not in ns0.CreateVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.CreateVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.CreateVirtualDiskRequestType_Def) - ns0.CreateVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.CreateVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateVirtualDisk_Task_Dec_Holder" - - class CreateVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateVirtualDisk_TaskResponse") - kw["aname"] = "_CreateVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class DeleteVirtualDisk_Dec(ElementDeclaration): - literal = "DeleteVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeleteVirtualDisk") - kw["aname"] = "_DeleteVirtualDisk" - if ns0.DeleteVirtualDiskRequestType_Def not in ns0.DeleteVirtualDisk_Dec.__bases__: - bases = list(ns0.DeleteVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.DeleteVirtualDiskRequestType_Def) - ns0.DeleteVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.DeleteVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeleteVirtualDisk_Dec_Holder" - - class DeleteVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DeleteVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DeleteVirtualDiskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DeleteVirtualDiskResponse") - kw["aname"] = "_DeleteVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DeleteVirtualDiskResponse_Holder" - self.pyclass = Holder - - class DeleteVirtualDisk_Task_Dec(ElementDeclaration): - literal = "DeleteVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeleteVirtualDisk_Task") - kw["aname"] = "_DeleteVirtualDisk_Task" - if ns0.DeleteVirtualDiskRequestType_Def not in ns0.DeleteVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.DeleteVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.DeleteVirtualDiskRequestType_Def) - ns0.DeleteVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.DeleteVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeleteVirtualDisk_Task_Dec_Holder" - - class DeleteVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DeleteVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DeleteVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DeleteVirtualDisk_TaskResponse") - kw["aname"] = "_DeleteVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DeleteVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class MoveVirtualDisk_Dec(ElementDeclaration): - literal = "MoveVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveVirtualDisk") - kw["aname"] = "_MoveVirtualDisk" - if ns0.MoveVirtualDiskRequestType_Def not in ns0.MoveVirtualDisk_Dec.__bases__: - bases = list(ns0.MoveVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.MoveVirtualDiskRequestType_Def) - ns0.MoveVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.MoveVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveVirtualDisk_Dec_Holder" - - class MoveVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveVirtualDiskResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MoveVirtualDiskResponse") - kw["aname"] = "_MoveVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MoveVirtualDiskResponse_Holder" - self.pyclass = Holder - - class MoveVirtualDisk_Task_Dec(ElementDeclaration): - literal = "MoveVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MoveVirtualDisk_Task") - kw["aname"] = "_MoveVirtualDisk_Task" - if ns0.MoveVirtualDiskRequestType_Def not in ns0.MoveVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.MoveVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.MoveVirtualDiskRequestType_Def) - ns0.MoveVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.MoveVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MoveVirtualDisk_Task_Dec_Holder" - - class MoveVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MoveVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MoveVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MoveVirtualDisk_TaskResponse") - kw["aname"] = "_MoveVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MoveVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class CopyVirtualDisk_Dec(ElementDeclaration): - literal = "CopyVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CopyVirtualDisk") - kw["aname"] = "_CopyVirtualDisk" - if ns0.CopyVirtualDiskRequestType_Def not in ns0.CopyVirtualDisk_Dec.__bases__: - bases = list(ns0.CopyVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.CopyVirtualDiskRequestType_Def) - ns0.CopyVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.CopyVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CopyVirtualDisk_Dec_Holder" - - class CopyVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CopyVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CopyVirtualDiskResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CopyVirtualDiskResponse") - kw["aname"] = "_CopyVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CopyVirtualDiskResponse_Holder" - self.pyclass = Holder - - class CopyVirtualDisk_Task_Dec(ElementDeclaration): - literal = "CopyVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CopyVirtualDisk_Task") - kw["aname"] = "_CopyVirtualDisk_Task" - if ns0.CopyVirtualDiskRequestType_Def not in ns0.CopyVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.CopyVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.CopyVirtualDiskRequestType_Def) - ns0.CopyVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.CopyVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CopyVirtualDisk_Task_Dec_Holder" - - class CopyVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CopyVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CopyVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CopyVirtualDisk_TaskResponse") - kw["aname"] = "_CopyVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CopyVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class ExtendVirtualDisk_Dec(ElementDeclaration): - literal = "ExtendVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExtendVirtualDisk") - kw["aname"] = "_ExtendVirtualDisk" - if ns0.ExtendVirtualDiskRequestType_Def not in ns0.ExtendVirtualDisk_Dec.__bases__: - bases = list(ns0.ExtendVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.ExtendVirtualDiskRequestType_Def) - ns0.ExtendVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.ExtendVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExtendVirtualDisk_Dec_Holder" - - class ExtendVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExtendVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExtendVirtualDiskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ExtendVirtualDiskResponse") - kw["aname"] = "_ExtendVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ExtendVirtualDiskResponse_Holder" - self.pyclass = Holder - - class ExtendVirtualDisk_Task_Dec(ElementDeclaration): - literal = "ExtendVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExtendVirtualDisk_Task") - kw["aname"] = "_ExtendVirtualDisk_Task" - if ns0.ExtendVirtualDiskRequestType_Def not in ns0.ExtendVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.ExtendVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.ExtendVirtualDiskRequestType_Def) - ns0.ExtendVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.ExtendVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExtendVirtualDisk_Task_Dec_Holder" - - class ExtendVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExtendVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExtendVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ExtendVirtualDisk_TaskResponse") - kw["aname"] = "_ExtendVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ExtendVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class QueryVirtualDiskFragmentation_Dec(ElementDeclaration): - literal = "QueryVirtualDiskFragmentation" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVirtualDiskFragmentation") - kw["aname"] = "_QueryVirtualDiskFragmentation" - if ns0.QueryVirtualDiskFragmentationRequestType_Def not in ns0.QueryVirtualDiskFragmentation_Dec.__bases__: - bases = list(ns0.QueryVirtualDiskFragmentation_Dec.__bases__) - bases.insert(0, ns0.QueryVirtualDiskFragmentationRequestType_Def) - ns0.QueryVirtualDiskFragmentation_Dec.__bases__ = tuple(bases) - - ns0.QueryVirtualDiskFragmentationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVirtualDiskFragmentation_Dec_Holder" - - class QueryVirtualDiskFragmentationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVirtualDiskFragmentationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVirtualDiskFragmentationResponse_Dec.schema - TClist = [ZSI.TCnumbers.Iint(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVirtualDiskFragmentationResponse") - kw["aname"] = "_QueryVirtualDiskFragmentationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryVirtualDiskFragmentationResponse_Holder" - self.pyclass = Holder - - class DefragmentVirtualDisk_Dec(ElementDeclaration): - literal = "DefragmentVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DefragmentVirtualDisk") - kw["aname"] = "_DefragmentVirtualDisk" - if ns0.DefragmentVirtualDiskRequestType_Def not in ns0.DefragmentVirtualDisk_Dec.__bases__: - bases = list(ns0.DefragmentVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.DefragmentVirtualDiskRequestType_Def) - ns0.DefragmentVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.DefragmentVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DefragmentVirtualDisk_Dec_Holder" - - class DefragmentVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DefragmentVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DefragmentVirtualDiskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DefragmentVirtualDiskResponse") - kw["aname"] = "_DefragmentVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DefragmentVirtualDiskResponse_Holder" - self.pyclass = Holder - - class DefragmentVirtualDisk_Task_Dec(ElementDeclaration): - literal = "DefragmentVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DefragmentVirtualDisk_Task") - kw["aname"] = "_DefragmentVirtualDisk_Task" - if ns0.DefragmentVirtualDiskRequestType_Def not in ns0.DefragmentVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.DefragmentVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.DefragmentVirtualDiskRequestType_Def) - ns0.DefragmentVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.DefragmentVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DefragmentVirtualDisk_Task_Dec_Holder" - - class DefragmentVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DefragmentVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DefragmentVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DefragmentVirtualDisk_TaskResponse") - kw["aname"] = "_DefragmentVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DefragmentVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class ShrinkVirtualDisk_Dec(ElementDeclaration): - literal = "ShrinkVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ShrinkVirtualDisk") - kw["aname"] = "_ShrinkVirtualDisk" - if ns0.ShrinkVirtualDiskRequestType_Def not in ns0.ShrinkVirtualDisk_Dec.__bases__: - bases = list(ns0.ShrinkVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.ShrinkVirtualDiskRequestType_Def) - ns0.ShrinkVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.ShrinkVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ShrinkVirtualDisk_Dec_Holder" - - class ShrinkVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ShrinkVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ShrinkVirtualDiskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ShrinkVirtualDiskResponse") - kw["aname"] = "_ShrinkVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ShrinkVirtualDiskResponse_Holder" - self.pyclass = Holder - - class ShrinkVirtualDisk_Task_Dec(ElementDeclaration): - literal = "ShrinkVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ShrinkVirtualDisk_Task") - kw["aname"] = "_ShrinkVirtualDisk_Task" - if ns0.ShrinkVirtualDiskRequestType_Def not in ns0.ShrinkVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.ShrinkVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.ShrinkVirtualDiskRequestType_Def) - ns0.ShrinkVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.ShrinkVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ShrinkVirtualDisk_Task_Dec_Holder" - - class ShrinkVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ShrinkVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ShrinkVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ShrinkVirtualDisk_TaskResponse") - kw["aname"] = "_ShrinkVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ShrinkVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class InflateVirtualDisk_Dec(ElementDeclaration): - literal = "InflateVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InflateVirtualDisk") - kw["aname"] = "_InflateVirtualDisk" - if ns0.InflateVirtualDiskRequestType_Def not in ns0.InflateVirtualDisk_Dec.__bases__: - bases = list(ns0.InflateVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.InflateVirtualDiskRequestType_Def) - ns0.InflateVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.InflateVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InflateVirtualDisk_Dec_Holder" - - class InflateVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "InflateVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.InflateVirtualDiskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","InflateVirtualDiskResponse") - kw["aname"] = "_InflateVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "InflateVirtualDiskResponse_Holder" - self.pyclass = Holder - - class InflateVirtualDisk_Task_Dec(ElementDeclaration): - literal = "InflateVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InflateVirtualDisk_Task") - kw["aname"] = "_InflateVirtualDisk_Task" - if ns0.InflateVirtualDiskRequestType_Def not in ns0.InflateVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.InflateVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.InflateVirtualDiskRequestType_Def) - ns0.InflateVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.InflateVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InflateVirtualDisk_Task_Dec_Holder" - - class InflateVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "InflateVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.InflateVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","InflateVirtualDisk_TaskResponse") - kw["aname"] = "_InflateVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "InflateVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class EagerZeroVirtualDisk_Dec(ElementDeclaration): - literal = "EagerZeroVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EagerZeroVirtualDisk") - kw["aname"] = "_EagerZeroVirtualDisk" - if ns0.EagerZeroVirtualDiskRequestType_Def not in ns0.EagerZeroVirtualDisk_Dec.__bases__: - bases = list(ns0.EagerZeroVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.EagerZeroVirtualDiskRequestType_Def) - ns0.EagerZeroVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.EagerZeroVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EagerZeroVirtualDisk_Dec_Holder" - - class EagerZeroVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EagerZeroVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EagerZeroVirtualDiskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","EagerZeroVirtualDiskResponse") - kw["aname"] = "_EagerZeroVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "EagerZeroVirtualDiskResponse_Holder" - self.pyclass = Holder - - class EagerZeroVirtualDisk_Task_Dec(ElementDeclaration): - literal = "EagerZeroVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EagerZeroVirtualDisk_Task") - kw["aname"] = "_EagerZeroVirtualDisk_Task" - if ns0.EagerZeroVirtualDiskRequestType_Def not in ns0.EagerZeroVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.EagerZeroVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.EagerZeroVirtualDiskRequestType_Def) - ns0.EagerZeroVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.EagerZeroVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EagerZeroVirtualDisk_Task_Dec_Holder" - - class EagerZeroVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EagerZeroVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EagerZeroVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","EagerZeroVirtualDisk_TaskResponse") - kw["aname"] = "_EagerZeroVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "EagerZeroVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class ZeroFillVirtualDisk_Dec(ElementDeclaration): - literal = "ZeroFillVirtualDisk" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ZeroFillVirtualDisk") - kw["aname"] = "_ZeroFillVirtualDisk" - if ns0.ZeroFillVirtualDiskRequestType_Def not in ns0.ZeroFillVirtualDisk_Dec.__bases__: - bases = list(ns0.ZeroFillVirtualDisk_Dec.__bases__) - bases.insert(0, ns0.ZeroFillVirtualDiskRequestType_Def) - ns0.ZeroFillVirtualDisk_Dec.__bases__ = tuple(bases) - - ns0.ZeroFillVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ZeroFillVirtualDisk_Dec_Holder" - - class ZeroFillVirtualDiskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ZeroFillVirtualDiskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ZeroFillVirtualDiskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ZeroFillVirtualDiskResponse") - kw["aname"] = "_ZeroFillVirtualDiskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ZeroFillVirtualDiskResponse_Holder" - self.pyclass = Holder - - class ZeroFillVirtualDisk_Task_Dec(ElementDeclaration): - literal = "ZeroFillVirtualDisk_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ZeroFillVirtualDisk_Task") - kw["aname"] = "_ZeroFillVirtualDisk_Task" - if ns0.ZeroFillVirtualDiskRequestType_Def not in ns0.ZeroFillVirtualDisk_Task_Dec.__bases__: - bases = list(ns0.ZeroFillVirtualDisk_Task_Dec.__bases__) - bases.insert(0, ns0.ZeroFillVirtualDiskRequestType_Def) - ns0.ZeroFillVirtualDisk_Task_Dec.__bases__ = tuple(bases) - - ns0.ZeroFillVirtualDiskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ZeroFillVirtualDisk_Task_Dec_Holder" - - class ZeroFillVirtualDisk_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ZeroFillVirtualDisk_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ZeroFillVirtualDisk_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ZeroFillVirtualDisk_TaskResponse") - kw["aname"] = "_ZeroFillVirtualDisk_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ZeroFillVirtualDisk_TaskResponse_Holder" - self.pyclass = Holder - - class SetVirtualDiskUuid_Dec(ElementDeclaration): - literal = "SetVirtualDiskUuid" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetVirtualDiskUuid") - kw["aname"] = "_SetVirtualDiskUuid" - if ns0.SetVirtualDiskUuidRequestType_Def not in ns0.SetVirtualDiskUuid_Dec.__bases__: - bases = list(ns0.SetVirtualDiskUuid_Dec.__bases__) - bases.insert(0, ns0.SetVirtualDiskUuidRequestType_Def) - ns0.SetVirtualDiskUuid_Dec.__bases__ = tuple(bases) - - ns0.SetVirtualDiskUuidRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetVirtualDiskUuid_Dec_Holder" - - class SetVirtualDiskUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetVirtualDiskUuidResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetVirtualDiskUuidResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetVirtualDiskUuidResponse") - kw["aname"] = "_SetVirtualDiskUuidResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetVirtualDiskUuidResponse_Holder" - self.pyclass = Holder - - class QueryVirtualDiskUuid_Dec(ElementDeclaration): - literal = "QueryVirtualDiskUuid" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVirtualDiskUuid") - kw["aname"] = "_QueryVirtualDiskUuid" - if ns0.QueryVirtualDiskUuidRequestType_Def not in ns0.QueryVirtualDiskUuid_Dec.__bases__: - bases = list(ns0.QueryVirtualDiskUuid_Dec.__bases__) - bases.insert(0, ns0.QueryVirtualDiskUuidRequestType_Def) - ns0.QueryVirtualDiskUuid_Dec.__bases__ = tuple(bases) - - ns0.QueryVirtualDiskUuidRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVirtualDiskUuid_Dec_Holder" - - class QueryVirtualDiskUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVirtualDiskUuidResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVirtualDiskUuidResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVirtualDiskUuidResponse") - kw["aname"] = "_QueryVirtualDiskUuidResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryVirtualDiskUuidResponse_Holder" - self.pyclass = Holder - - class QueryVirtualDiskGeometry_Dec(ElementDeclaration): - literal = "QueryVirtualDiskGeometry" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVirtualDiskGeometry") - kw["aname"] = "_QueryVirtualDiskGeometry" - if ns0.QueryVirtualDiskGeometryRequestType_Def not in ns0.QueryVirtualDiskGeometry_Dec.__bases__: - bases = list(ns0.QueryVirtualDiskGeometry_Dec.__bases__) - bases.insert(0, ns0.QueryVirtualDiskGeometryRequestType_Def) - ns0.QueryVirtualDiskGeometry_Dec.__bases__ = tuple(bases) - - ns0.QueryVirtualDiskGeometryRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVirtualDiskGeometry_Dec_Holder" - - class QueryVirtualDiskGeometryResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVirtualDiskGeometryResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVirtualDiskGeometryResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDiskDimensionsChs",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVirtualDiskGeometryResponse") - kw["aname"] = "_QueryVirtualDiskGeometryResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryVirtualDiskGeometryResponse_Holder" - self.pyclass = Holder - - class RefreshStorageInfo_Dec(ElementDeclaration): - literal = "RefreshStorageInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshStorageInfo") - kw["aname"] = "_RefreshStorageInfo" - if ns0.RefreshStorageInfoRequestType_Def not in ns0.RefreshStorageInfo_Dec.__bases__: - bases = list(ns0.RefreshStorageInfo_Dec.__bases__) - bases.insert(0, ns0.RefreshStorageInfoRequestType_Def) - ns0.RefreshStorageInfo_Dec.__bases__ = tuple(bases) - - ns0.RefreshStorageInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshStorageInfo_Dec_Holder" - - class RefreshStorageInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshStorageInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshStorageInfoResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshStorageInfoResponse") - kw["aname"] = "_RefreshStorageInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshStorageInfoResponse_Holder" - self.pyclass = Holder - - class CreateSnapshot_Dec(ElementDeclaration): - literal = "CreateSnapshot" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateSnapshot") - kw["aname"] = "_CreateSnapshot" - if ns0.CreateSnapshotRequestType_Def not in ns0.CreateSnapshot_Dec.__bases__: - bases = list(ns0.CreateSnapshot_Dec.__bases__) - bases.insert(0, ns0.CreateSnapshotRequestType_Def) - ns0.CreateSnapshot_Dec.__bases__ = tuple(bases) - - ns0.CreateSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateSnapshot_Dec_Holder" - - class CreateSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateSnapshotResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateSnapshotResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateSnapshotResponse") - kw["aname"] = "_CreateSnapshotResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateSnapshotResponse_Holder" - self.pyclass = Holder - - class CreateSnapshot_Task_Dec(ElementDeclaration): - literal = "CreateSnapshot_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateSnapshot_Task") - kw["aname"] = "_CreateSnapshot_Task" - if ns0.CreateSnapshotRequestType_Def not in ns0.CreateSnapshot_Task_Dec.__bases__: - bases = list(ns0.CreateSnapshot_Task_Dec.__bases__) - bases.insert(0, ns0.CreateSnapshotRequestType_Def) - ns0.CreateSnapshot_Task_Dec.__bases__ = tuple(bases) - - ns0.CreateSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateSnapshot_Task_Dec_Holder" - - class CreateSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateSnapshot_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateSnapshot_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateSnapshot_TaskResponse") - kw["aname"] = "_CreateSnapshot_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateSnapshot_TaskResponse_Holder" - self.pyclass = Holder - - class RevertToCurrentSnapshot_Dec(ElementDeclaration): - literal = "RevertToCurrentSnapshot" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RevertToCurrentSnapshot") - kw["aname"] = "_RevertToCurrentSnapshot" - if ns0.RevertToCurrentSnapshotRequestType_Def not in ns0.RevertToCurrentSnapshot_Dec.__bases__: - bases = list(ns0.RevertToCurrentSnapshot_Dec.__bases__) - bases.insert(0, ns0.RevertToCurrentSnapshotRequestType_Def) - ns0.RevertToCurrentSnapshot_Dec.__bases__ = tuple(bases) - - ns0.RevertToCurrentSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RevertToCurrentSnapshot_Dec_Holder" - - class RevertToCurrentSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RevertToCurrentSnapshotResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RevertToCurrentSnapshotResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RevertToCurrentSnapshotResponse") - kw["aname"] = "_RevertToCurrentSnapshotResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RevertToCurrentSnapshotResponse_Holder" - self.pyclass = Holder - - class RevertToCurrentSnapshot_Task_Dec(ElementDeclaration): - literal = "RevertToCurrentSnapshot_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RevertToCurrentSnapshot_Task") - kw["aname"] = "_RevertToCurrentSnapshot_Task" - if ns0.RevertToCurrentSnapshotRequestType_Def not in ns0.RevertToCurrentSnapshot_Task_Dec.__bases__: - bases = list(ns0.RevertToCurrentSnapshot_Task_Dec.__bases__) - bases.insert(0, ns0.RevertToCurrentSnapshotRequestType_Def) - ns0.RevertToCurrentSnapshot_Task_Dec.__bases__ = tuple(bases) - - ns0.RevertToCurrentSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RevertToCurrentSnapshot_Task_Dec_Holder" - - class RevertToCurrentSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RevertToCurrentSnapshot_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RevertToCurrentSnapshot_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RevertToCurrentSnapshot_TaskResponse") - kw["aname"] = "_RevertToCurrentSnapshot_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RevertToCurrentSnapshot_TaskResponse_Holder" - self.pyclass = Holder - - class RemoveAllSnapshots_Dec(ElementDeclaration): - literal = "RemoveAllSnapshots" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveAllSnapshots") - kw["aname"] = "_RemoveAllSnapshots" - if ns0.RemoveAllSnapshotsRequestType_Def not in ns0.RemoveAllSnapshots_Dec.__bases__: - bases = list(ns0.RemoveAllSnapshots_Dec.__bases__) - bases.insert(0, ns0.RemoveAllSnapshotsRequestType_Def) - ns0.RemoveAllSnapshots_Dec.__bases__ = tuple(bases) - - ns0.RemoveAllSnapshotsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveAllSnapshots_Dec_Holder" - - class RemoveAllSnapshotsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveAllSnapshotsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveAllSnapshotsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveAllSnapshotsResponse") - kw["aname"] = "_RemoveAllSnapshotsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveAllSnapshotsResponse_Holder" - self.pyclass = Holder - - class RemoveAllSnapshots_Task_Dec(ElementDeclaration): - literal = "RemoveAllSnapshots_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveAllSnapshots_Task") - kw["aname"] = "_RemoveAllSnapshots_Task" - if ns0.RemoveAllSnapshotsRequestType_Def not in ns0.RemoveAllSnapshots_Task_Dec.__bases__: - bases = list(ns0.RemoveAllSnapshots_Task_Dec.__bases__) - bases.insert(0, ns0.RemoveAllSnapshotsRequestType_Def) - ns0.RemoveAllSnapshots_Task_Dec.__bases__ = tuple(bases) - - ns0.RemoveAllSnapshotsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveAllSnapshots_Task_Dec_Holder" - - class RemoveAllSnapshots_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveAllSnapshots_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveAllSnapshots_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RemoveAllSnapshots_TaskResponse") - kw["aname"] = "_RemoveAllSnapshots_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RemoveAllSnapshots_TaskResponse_Holder" - self.pyclass = Holder - - class ReconfigVM_Dec(ElementDeclaration): - literal = "ReconfigVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigVM") - kw["aname"] = "_ReconfigVM" - if ns0.ReconfigVMRequestType_Def not in ns0.ReconfigVM_Dec.__bases__: - bases = list(ns0.ReconfigVM_Dec.__bases__) - bases.insert(0, ns0.ReconfigVMRequestType_Def) - ns0.ReconfigVM_Dec.__bases__ = tuple(bases) - - ns0.ReconfigVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigVM_Dec_Holder" - - class ReconfigVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigVMResponse") - kw["aname"] = "_ReconfigVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigVMResponse_Holder" - self.pyclass = Holder - - class ReconfigVM_Task_Dec(ElementDeclaration): - literal = "ReconfigVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigVM_Task") - kw["aname"] = "_ReconfigVM_Task" - if ns0.ReconfigVMRequestType_Def not in ns0.ReconfigVM_Task_Dec.__bases__: - bases = list(ns0.ReconfigVM_Task_Dec.__bases__) - bases.insert(0, ns0.ReconfigVMRequestType_Def) - ns0.ReconfigVM_Task_Dec.__bases__ = tuple(bases) - - ns0.ReconfigVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigVM_Task_Dec_Holder" - - class ReconfigVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReconfigVM_TaskResponse") - kw["aname"] = "_ReconfigVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ReconfigVM_TaskResponse_Holder" - self.pyclass = Holder - - class UpgradeVM_Dec(ElementDeclaration): - literal = "UpgradeVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpgradeVM") - kw["aname"] = "_UpgradeVM" - if ns0.UpgradeVMRequestType_Def not in ns0.UpgradeVM_Dec.__bases__: - bases = list(ns0.UpgradeVM_Dec.__bases__) - bases.insert(0, ns0.UpgradeVMRequestType_Def) - ns0.UpgradeVM_Dec.__bases__ = tuple(bases) - - ns0.UpgradeVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVM_Dec_Holder" - - class UpgradeVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpgradeVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpgradeVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpgradeVMResponse") - kw["aname"] = "_UpgradeVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpgradeVMResponse_Holder" - self.pyclass = Holder - - class UpgradeVM_Task_Dec(ElementDeclaration): - literal = "UpgradeVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpgradeVM_Task") - kw["aname"] = "_UpgradeVM_Task" - if ns0.UpgradeVMRequestType_Def not in ns0.UpgradeVM_Task_Dec.__bases__: - bases = list(ns0.UpgradeVM_Task_Dec.__bases__) - bases.insert(0, ns0.UpgradeVMRequestType_Def) - ns0.UpgradeVM_Task_Dec.__bases__ = tuple(bases) - - ns0.UpgradeVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVM_Task_Dec_Holder" - - class UpgradeVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpgradeVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpgradeVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UpgradeVM_TaskResponse") - kw["aname"] = "_UpgradeVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UpgradeVM_TaskResponse_Holder" - self.pyclass = Holder - - class ExtractOvfEnvironment_Dec(ElementDeclaration): - literal = "ExtractOvfEnvironment" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExtractOvfEnvironment") - kw["aname"] = "_ExtractOvfEnvironment" - if ns0.ExtractOvfEnvironmentRequestType_Def not in ns0.ExtractOvfEnvironment_Dec.__bases__: - bases = list(ns0.ExtractOvfEnvironment_Dec.__bases__) - bases.insert(0, ns0.ExtractOvfEnvironmentRequestType_Def) - ns0.ExtractOvfEnvironment_Dec.__bases__ = tuple(bases) - - ns0.ExtractOvfEnvironmentRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExtractOvfEnvironment_Dec_Holder" - - class ExtractOvfEnvironmentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExtractOvfEnvironmentResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExtractOvfEnvironmentResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ExtractOvfEnvironmentResponse") - kw["aname"] = "_ExtractOvfEnvironmentResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ExtractOvfEnvironmentResponse_Holder" - self.pyclass = Holder - - class PowerOnVM_Dec(ElementDeclaration): - literal = "PowerOnVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnVM") - kw["aname"] = "_PowerOnVM" - if ns0.PowerOnVMRequestType_Def not in ns0.PowerOnVM_Dec.__bases__: - bases = list(ns0.PowerOnVM_Dec.__bases__) - bases.insert(0, ns0.PowerOnVMRequestType_Def) - ns0.PowerOnVM_Dec.__bases__ = tuple(bases) - - ns0.PowerOnVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVM_Dec_Holder" - - class PowerOnVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOnVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOnVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PowerOnVMResponse") - kw["aname"] = "_PowerOnVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PowerOnVMResponse_Holder" - self.pyclass = Holder - - class PowerOnVM_Task_Dec(ElementDeclaration): - literal = "PowerOnVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnVM_Task") - kw["aname"] = "_PowerOnVM_Task" - if ns0.PowerOnVMRequestType_Def not in ns0.PowerOnVM_Task_Dec.__bases__: - bases = list(ns0.PowerOnVM_Task_Dec.__bases__) - bases.insert(0, ns0.PowerOnVMRequestType_Def) - ns0.PowerOnVM_Task_Dec.__bases__ = tuple(bases) - - ns0.PowerOnVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnVM_Task_Dec_Holder" - - class PowerOnVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOnVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOnVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerOnVM_TaskResponse") - kw["aname"] = "_PowerOnVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerOnVM_TaskResponse_Holder" - self.pyclass = Holder - - class PowerOffVM_Dec(ElementDeclaration): - literal = "PowerOffVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOffVM") - kw["aname"] = "_PowerOffVM" - if ns0.PowerOffVMRequestType_Def not in ns0.PowerOffVM_Dec.__bases__: - bases = list(ns0.PowerOffVM_Dec.__bases__) - bases.insert(0, ns0.PowerOffVMRequestType_Def) - ns0.PowerOffVM_Dec.__bases__ = tuple(bases) - - ns0.PowerOffVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVM_Dec_Holder" - - class PowerOffVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOffVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOffVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PowerOffVMResponse") - kw["aname"] = "_PowerOffVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PowerOffVMResponse_Holder" - self.pyclass = Holder - - class PowerOffVM_Task_Dec(ElementDeclaration): - literal = "PowerOffVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOffVM_Task") - kw["aname"] = "_PowerOffVM_Task" - if ns0.PowerOffVMRequestType_Def not in ns0.PowerOffVM_Task_Dec.__bases__: - bases = list(ns0.PowerOffVM_Task_Dec.__bases__) - bases.insert(0, ns0.PowerOffVMRequestType_Def) - ns0.PowerOffVM_Task_Dec.__bases__ = tuple(bases) - - ns0.PowerOffVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOffVM_Task_Dec_Holder" - - class PowerOffVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PowerOffVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PowerOffVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PowerOffVM_TaskResponse") - kw["aname"] = "_PowerOffVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PowerOffVM_TaskResponse_Holder" - self.pyclass = Holder - - class SuspendVM_Dec(ElementDeclaration): - literal = "SuspendVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SuspendVM") - kw["aname"] = "_SuspendVM" - if ns0.SuspendVMRequestType_Def not in ns0.SuspendVM_Dec.__bases__: - bases = list(ns0.SuspendVM_Dec.__bases__) - bases.insert(0, ns0.SuspendVMRequestType_Def) - ns0.SuspendVM_Dec.__bases__ = tuple(bases) - - ns0.SuspendVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SuspendVM_Dec_Holder" - - class SuspendVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SuspendVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SuspendVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SuspendVMResponse") - kw["aname"] = "_SuspendVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SuspendVMResponse_Holder" - self.pyclass = Holder - - class SuspendVM_Task_Dec(ElementDeclaration): - literal = "SuspendVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SuspendVM_Task") - kw["aname"] = "_SuspendVM_Task" - if ns0.SuspendVMRequestType_Def not in ns0.SuspendVM_Task_Dec.__bases__: - bases = list(ns0.SuspendVM_Task_Dec.__bases__) - bases.insert(0, ns0.SuspendVMRequestType_Def) - ns0.SuspendVM_Task_Dec.__bases__ = tuple(bases) - - ns0.SuspendVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SuspendVM_Task_Dec_Holder" - - class SuspendVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SuspendVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SuspendVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","SuspendVM_TaskResponse") - kw["aname"] = "_SuspendVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "SuspendVM_TaskResponse_Holder" - self.pyclass = Holder - - class ResetVM_Dec(ElementDeclaration): - literal = "ResetVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetVM") - kw["aname"] = "_ResetVM" - if ns0.ResetVMRequestType_Def not in ns0.ResetVM_Dec.__bases__: - bases = list(ns0.ResetVM_Dec.__bases__) - bases.insert(0, ns0.ResetVMRequestType_Def) - ns0.ResetVM_Dec.__bases__ = tuple(bases) - - ns0.ResetVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetVM_Dec_Holder" - - class ResetVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetVMResponse") - kw["aname"] = "_ResetVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetVMResponse_Holder" - self.pyclass = Holder - - class ResetVM_Task_Dec(ElementDeclaration): - literal = "ResetVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetVM_Task") - kw["aname"] = "_ResetVM_Task" - if ns0.ResetVMRequestType_Def not in ns0.ResetVM_Task_Dec.__bases__: - bases = list(ns0.ResetVM_Task_Dec.__bases__) - bases.insert(0, ns0.ResetVMRequestType_Def) - ns0.ResetVM_Task_Dec.__bases__ = tuple(bases) - - ns0.ResetVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetVM_Task_Dec_Holder" - - class ResetVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ResetVM_TaskResponse") - kw["aname"] = "_ResetVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ResetVM_TaskResponse_Holder" - self.pyclass = Holder - - class ShutdownGuest_Dec(ElementDeclaration): - literal = "ShutdownGuest" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ShutdownGuest") - kw["aname"] = "_ShutdownGuest" - if ns0.ShutdownGuestRequestType_Def not in ns0.ShutdownGuest_Dec.__bases__: - bases = list(ns0.ShutdownGuest_Dec.__bases__) - bases.insert(0, ns0.ShutdownGuestRequestType_Def) - ns0.ShutdownGuest_Dec.__bases__ = tuple(bases) - - ns0.ShutdownGuestRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ShutdownGuest_Dec_Holder" - - class ShutdownGuestResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ShutdownGuestResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ShutdownGuestResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ShutdownGuestResponse") - kw["aname"] = "_ShutdownGuestResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ShutdownGuestResponse_Holder" - self.pyclass = Holder - - class RebootGuest_Dec(ElementDeclaration): - literal = "RebootGuest" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RebootGuest") - kw["aname"] = "_RebootGuest" - if ns0.RebootGuestRequestType_Def not in ns0.RebootGuest_Dec.__bases__: - bases = list(ns0.RebootGuest_Dec.__bases__) - bases.insert(0, ns0.RebootGuestRequestType_Def) - ns0.RebootGuest_Dec.__bases__ = tuple(bases) - - ns0.RebootGuestRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RebootGuest_Dec_Holder" - - class RebootGuestResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RebootGuestResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RebootGuestResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RebootGuestResponse") - kw["aname"] = "_RebootGuestResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RebootGuestResponse_Holder" - self.pyclass = Holder - - class StandbyGuest_Dec(ElementDeclaration): - literal = "StandbyGuest" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StandbyGuest") - kw["aname"] = "_StandbyGuest" - if ns0.StandbyGuestRequestType_Def not in ns0.StandbyGuest_Dec.__bases__: - bases = list(ns0.StandbyGuest_Dec.__bases__) - bases.insert(0, ns0.StandbyGuestRequestType_Def) - ns0.StandbyGuest_Dec.__bases__ = tuple(bases) - - ns0.StandbyGuestRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StandbyGuest_Dec_Holder" - - class StandbyGuestResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StandbyGuestResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StandbyGuestResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","StandbyGuestResponse") - kw["aname"] = "_StandbyGuestResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "StandbyGuestResponse_Holder" - self.pyclass = Holder - - class AnswerVM_Dec(ElementDeclaration): - literal = "AnswerVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AnswerVM") - kw["aname"] = "_AnswerVM" - if ns0.AnswerVMRequestType_Def not in ns0.AnswerVM_Dec.__bases__: - bases = list(ns0.AnswerVM_Dec.__bases__) - bases.insert(0, ns0.AnswerVMRequestType_Def) - ns0.AnswerVM_Dec.__bases__ = tuple(bases) - - ns0.AnswerVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AnswerVM_Dec_Holder" - - class AnswerVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AnswerVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AnswerVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AnswerVMResponse") - kw["aname"] = "_AnswerVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AnswerVMResponse_Holder" - self.pyclass = Holder - - class CustomizeVM_Dec(ElementDeclaration): - literal = "CustomizeVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CustomizeVM") - kw["aname"] = "_CustomizeVM" - if ns0.CustomizeVMRequestType_Def not in ns0.CustomizeVM_Dec.__bases__: - bases = list(ns0.CustomizeVM_Dec.__bases__) - bases.insert(0, ns0.CustomizeVMRequestType_Def) - ns0.CustomizeVM_Dec.__bases__ = tuple(bases) - - ns0.CustomizeVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CustomizeVM_Dec_Holder" - - class CustomizeVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CustomizeVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CustomizeVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CustomizeVMResponse") - kw["aname"] = "_CustomizeVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CustomizeVMResponse_Holder" - self.pyclass = Holder - - class CustomizeVM_Task_Dec(ElementDeclaration): - literal = "CustomizeVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CustomizeVM_Task") - kw["aname"] = "_CustomizeVM_Task" - if ns0.CustomizeVMRequestType_Def not in ns0.CustomizeVM_Task_Dec.__bases__: - bases = list(ns0.CustomizeVM_Task_Dec.__bases__) - bases.insert(0, ns0.CustomizeVMRequestType_Def) - ns0.CustomizeVM_Task_Dec.__bases__ = tuple(bases) - - ns0.CustomizeVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CustomizeVM_Task_Dec_Holder" - - class CustomizeVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CustomizeVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CustomizeVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CustomizeVM_TaskResponse") - kw["aname"] = "_CustomizeVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CustomizeVM_TaskResponse_Holder" - self.pyclass = Holder - - class CheckCustomizationSpec_Dec(ElementDeclaration): - literal = "CheckCustomizationSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckCustomizationSpec") - kw["aname"] = "_CheckCustomizationSpec" - if ns0.CheckCustomizationSpecRequestType_Def not in ns0.CheckCustomizationSpec_Dec.__bases__: - bases = list(ns0.CheckCustomizationSpec_Dec.__bases__) - bases.insert(0, ns0.CheckCustomizationSpecRequestType_Def) - ns0.CheckCustomizationSpec_Dec.__bases__ = tuple(bases) - - ns0.CheckCustomizationSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckCustomizationSpec_Dec_Holder" - - class CheckCustomizationSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckCustomizationSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckCustomizationSpecResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CheckCustomizationSpecResponse") - kw["aname"] = "_CheckCustomizationSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CheckCustomizationSpecResponse_Holder" - self.pyclass = Holder - - class MigrateVM_Dec(ElementDeclaration): - literal = "MigrateVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MigrateVM") - kw["aname"] = "_MigrateVM" - if ns0.MigrateVMRequestType_Def not in ns0.MigrateVM_Dec.__bases__: - bases = list(ns0.MigrateVM_Dec.__bases__) - bases.insert(0, ns0.MigrateVMRequestType_Def) - ns0.MigrateVM_Dec.__bases__ = tuple(bases) - - ns0.MigrateVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MigrateVM_Dec_Holder" - - class MigrateVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MigrateVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MigrateVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MigrateVMResponse") - kw["aname"] = "_MigrateVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MigrateVMResponse_Holder" - self.pyclass = Holder - - class MigrateVM_Task_Dec(ElementDeclaration): - literal = "MigrateVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MigrateVM_Task") - kw["aname"] = "_MigrateVM_Task" - if ns0.MigrateVMRequestType_Def not in ns0.MigrateVM_Task_Dec.__bases__: - bases = list(ns0.MigrateVM_Task_Dec.__bases__) - bases.insert(0, ns0.MigrateVMRequestType_Def) - ns0.MigrateVM_Task_Dec.__bases__ = tuple(bases) - - ns0.MigrateVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MigrateVM_Task_Dec_Holder" - - class MigrateVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MigrateVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MigrateVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MigrateVM_TaskResponse") - kw["aname"] = "_MigrateVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MigrateVM_TaskResponse_Holder" - self.pyclass = Holder - - class RelocateVM_Dec(ElementDeclaration): - literal = "RelocateVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RelocateVM") - kw["aname"] = "_RelocateVM" - if ns0.RelocateVMRequestType_Def not in ns0.RelocateVM_Dec.__bases__: - bases = list(ns0.RelocateVM_Dec.__bases__) - bases.insert(0, ns0.RelocateVMRequestType_Def) - ns0.RelocateVM_Dec.__bases__ = tuple(bases) - - ns0.RelocateVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RelocateVM_Dec_Holder" - - class RelocateVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RelocateVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RelocateVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RelocateVMResponse") - kw["aname"] = "_RelocateVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RelocateVMResponse_Holder" - self.pyclass = Holder - - class RelocateVM_Task_Dec(ElementDeclaration): - literal = "RelocateVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RelocateVM_Task") - kw["aname"] = "_RelocateVM_Task" - if ns0.RelocateVMRequestType_Def not in ns0.RelocateVM_Task_Dec.__bases__: - bases = list(ns0.RelocateVM_Task_Dec.__bases__) - bases.insert(0, ns0.RelocateVMRequestType_Def) - ns0.RelocateVM_Task_Dec.__bases__ = tuple(bases) - - ns0.RelocateVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RelocateVM_Task_Dec_Holder" - - class RelocateVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RelocateVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RelocateVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RelocateVM_TaskResponse") - kw["aname"] = "_RelocateVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RelocateVM_TaskResponse_Holder" - self.pyclass = Holder - - class CloneVM_Dec(ElementDeclaration): - literal = "CloneVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CloneVM") - kw["aname"] = "_CloneVM" - if ns0.CloneVMRequestType_Def not in ns0.CloneVM_Dec.__bases__: - bases = list(ns0.CloneVM_Dec.__bases__) - bases.insert(0, ns0.CloneVMRequestType_Def) - ns0.CloneVM_Dec.__bases__ = tuple(bases) - - ns0.CloneVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CloneVM_Dec_Holder" - - class CloneVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CloneVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CloneVMResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CloneVMResponse") - kw["aname"] = "_CloneVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CloneVMResponse_Holder" - self.pyclass = Holder - - class CloneVM_Task_Dec(ElementDeclaration): - literal = "CloneVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CloneVM_Task") - kw["aname"] = "_CloneVM_Task" - if ns0.CloneVMRequestType_Def not in ns0.CloneVM_Task_Dec.__bases__: - bases = list(ns0.CloneVM_Task_Dec.__bases__) - bases.insert(0, ns0.CloneVMRequestType_Def) - ns0.CloneVM_Task_Dec.__bases__ = tuple(bases) - - ns0.CloneVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CloneVM_Task_Dec_Holder" - - class CloneVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CloneVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CloneVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CloneVM_TaskResponse") - kw["aname"] = "_CloneVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CloneVM_TaskResponse_Holder" - self.pyclass = Holder - - class ExportVm_Dec(ElementDeclaration): - literal = "ExportVm" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExportVm") - kw["aname"] = "_ExportVm" - if ns0.ExportVmRequestType_Def not in ns0.ExportVm_Dec.__bases__: - bases = list(ns0.ExportVm_Dec.__bases__) - bases.insert(0, ns0.ExportVmRequestType_Def) - ns0.ExportVm_Dec.__bases__ = tuple(bases) - - ns0.ExportVmRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExportVm_Dec_Holder" - - class ExportVmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExportVmResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExportVmResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ExportVmResponse") - kw["aname"] = "_ExportVmResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ExportVmResponse_Holder" - self.pyclass = Holder - - class MarkAsTemplate_Dec(ElementDeclaration): - literal = "MarkAsTemplate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MarkAsTemplate") - kw["aname"] = "_MarkAsTemplate" - if ns0.MarkAsTemplateRequestType_Def not in ns0.MarkAsTemplate_Dec.__bases__: - bases = list(ns0.MarkAsTemplate_Dec.__bases__) - bases.insert(0, ns0.MarkAsTemplateRequestType_Def) - ns0.MarkAsTemplate_Dec.__bases__ = tuple(bases) - - ns0.MarkAsTemplateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MarkAsTemplate_Dec_Holder" - - class MarkAsTemplateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MarkAsTemplateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MarkAsTemplateResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MarkAsTemplateResponse") - kw["aname"] = "_MarkAsTemplateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MarkAsTemplateResponse_Holder" - self.pyclass = Holder - - class MarkAsVirtualMachine_Dec(ElementDeclaration): - literal = "MarkAsVirtualMachine" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MarkAsVirtualMachine") - kw["aname"] = "_MarkAsVirtualMachine" - if ns0.MarkAsVirtualMachineRequestType_Def not in ns0.MarkAsVirtualMachine_Dec.__bases__: - bases = list(ns0.MarkAsVirtualMachine_Dec.__bases__) - bases.insert(0, ns0.MarkAsVirtualMachineRequestType_Def) - ns0.MarkAsVirtualMachine_Dec.__bases__ = tuple(bases) - - ns0.MarkAsVirtualMachineRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MarkAsVirtualMachine_Dec_Holder" - - class MarkAsVirtualMachineResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MarkAsVirtualMachineResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MarkAsVirtualMachineResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MarkAsVirtualMachineResponse") - kw["aname"] = "_MarkAsVirtualMachineResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MarkAsVirtualMachineResponse_Holder" - self.pyclass = Holder - - class UnregisterVM_Dec(ElementDeclaration): - literal = "UnregisterVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnregisterVM") - kw["aname"] = "_UnregisterVM" - if ns0.UnregisterVMRequestType_Def not in ns0.UnregisterVM_Dec.__bases__: - bases = list(ns0.UnregisterVM_Dec.__bases__) - bases.insert(0, ns0.UnregisterVMRequestType_Def) - ns0.UnregisterVM_Dec.__bases__ = tuple(bases) - - ns0.UnregisterVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnregisterVM_Dec_Holder" - - class UnregisterVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UnregisterVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UnregisterVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UnregisterVMResponse") - kw["aname"] = "_UnregisterVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UnregisterVMResponse_Holder" - self.pyclass = Holder - - class ResetGuestInformation_Dec(ElementDeclaration): - literal = "ResetGuestInformation" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetGuestInformation") - kw["aname"] = "_ResetGuestInformation" - if ns0.ResetGuestInformationRequestType_Def not in ns0.ResetGuestInformation_Dec.__bases__: - bases = list(ns0.ResetGuestInformation_Dec.__bases__) - bases.insert(0, ns0.ResetGuestInformationRequestType_Def) - ns0.ResetGuestInformation_Dec.__bases__ = tuple(bases) - - ns0.ResetGuestInformationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetGuestInformation_Dec_Holder" - - class ResetGuestInformationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetGuestInformationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetGuestInformationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetGuestInformationResponse") - kw["aname"] = "_ResetGuestInformationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetGuestInformationResponse_Holder" - self.pyclass = Holder - - class MountToolsInstaller_Dec(ElementDeclaration): - literal = "MountToolsInstaller" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MountToolsInstaller") - kw["aname"] = "_MountToolsInstaller" - if ns0.MountToolsInstallerRequestType_Def not in ns0.MountToolsInstaller_Dec.__bases__: - bases = list(ns0.MountToolsInstaller_Dec.__bases__) - bases.insert(0, ns0.MountToolsInstallerRequestType_Def) - ns0.MountToolsInstaller_Dec.__bases__ = tuple(bases) - - ns0.MountToolsInstallerRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MountToolsInstaller_Dec_Holder" - - class MountToolsInstallerResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MountToolsInstallerResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MountToolsInstallerResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MountToolsInstallerResponse") - kw["aname"] = "_MountToolsInstallerResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MountToolsInstallerResponse_Holder" - self.pyclass = Holder - - class UnmountToolsInstaller_Dec(ElementDeclaration): - literal = "UnmountToolsInstaller" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnmountToolsInstaller") - kw["aname"] = "_UnmountToolsInstaller" - if ns0.UnmountToolsInstallerRequestType_Def not in ns0.UnmountToolsInstaller_Dec.__bases__: - bases = list(ns0.UnmountToolsInstaller_Dec.__bases__) - bases.insert(0, ns0.UnmountToolsInstallerRequestType_Def) - ns0.UnmountToolsInstaller_Dec.__bases__ = tuple(bases) - - ns0.UnmountToolsInstallerRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnmountToolsInstaller_Dec_Holder" - - class UnmountToolsInstallerResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UnmountToolsInstallerResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UnmountToolsInstallerResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UnmountToolsInstallerResponse") - kw["aname"] = "_UnmountToolsInstallerResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UnmountToolsInstallerResponse_Holder" - self.pyclass = Holder - - class UpgradeTools_Dec(ElementDeclaration): - literal = "UpgradeTools" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpgradeTools") - kw["aname"] = "_UpgradeTools" - if ns0.UpgradeToolsRequestType_Def not in ns0.UpgradeTools_Dec.__bases__: - bases = list(ns0.UpgradeTools_Dec.__bases__) - bases.insert(0, ns0.UpgradeToolsRequestType_Def) - ns0.UpgradeTools_Dec.__bases__ = tuple(bases) - - ns0.UpgradeToolsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpgradeTools_Dec_Holder" - - class UpgradeToolsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpgradeToolsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpgradeToolsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpgradeToolsResponse") - kw["aname"] = "_UpgradeToolsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpgradeToolsResponse_Holder" - self.pyclass = Holder - - class UpgradeTools_Task_Dec(ElementDeclaration): - literal = "UpgradeTools_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpgradeTools_Task") - kw["aname"] = "_UpgradeTools_Task" - if ns0.UpgradeToolsRequestType_Def not in ns0.UpgradeTools_Task_Dec.__bases__: - bases = list(ns0.UpgradeTools_Task_Dec.__bases__) - bases.insert(0, ns0.UpgradeToolsRequestType_Def) - ns0.UpgradeTools_Task_Dec.__bases__ = tuple(bases) - - ns0.UpgradeToolsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpgradeTools_Task_Dec_Holder" - - class UpgradeTools_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpgradeTools_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpgradeTools_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UpgradeTools_TaskResponse") - kw["aname"] = "_UpgradeTools_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UpgradeTools_TaskResponse_Holder" - self.pyclass = Holder - - class AcquireMksTicket_Dec(ElementDeclaration): - literal = "AcquireMksTicket" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AcquireMksTicket") - kw["aname"] = "_AcquireMksTicket" - if ns0.AcquireMksTicketRequestType_Def not in ns0.AcquireMksTicket_Dec.__bases__: - bases = list(ns0.AcquireMksTicket_Dec.__bases__) - bases.insert(0, ns0.AcquireMksTicketRequestType_Def) - ns0.AcquireMksTicket_Dec.__bases__ = tuple(bases) - - ns0.AcquireMksTicketRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AcquireMksTicket_Dec_Holder" - - class AcquireMksTicketResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AcquireMksTicketResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AcquireMksTicketResponse_Dec.schema - TClist = [GTD("urn:vim25","VirtualMachineMksTicket",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AcquireMksTicketResponse") - kw["aname"] = "_AcquireMksTicketResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AcquireMksTicketResponse_Holder" - self.pyclass = Holder - - class SetScreenResolution_Dec(ElementDeclaration): - literal = "SetScreenResolution" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetScreenResolution") - kw["aname"] = "_SetScreenResolution" - if ns0.SetScreenResolutionRequestType_Def not in ns0.SetScreenResolution_Dec.__bases__: - bases = list(ns0.SetScreenResolution_Dec.__bases__) - bases.insert(0, ns0.SetScreenResolutionRequestType_Def) - ns0.SetScreenResolution_Dec.__bases__ = tuple(bases) - - ns0.SetScreenResolutionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetScreenResolution_Dec_Holder" - - class SetScreenResolutionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetScreenResolutionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetScreenResolutionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetScreenResolutionResponse") - kw["aname"] = "_SetScreenResolutionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetScreenResolutionResponse_Holder" - self.pyclass = Holder - - class DefragmentAllDisks_Dec(ElementDeclaration): - literal = "DefragmentAllDisks" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DefragmentAllDisks") - kw["aname"] = "_DefragmentAllDisks" - if ns0.DefragmentAllDisksRequestType_Def not in ns0.DefragmentAllDisks_Dec.__bases__: - bases = list(ns0.DefragmentAllDisks_Dec.__bases__) - bases.insert(0, ns0.DefragmentAllDisksRequestType_Def) - ns0.DefragmentAllDisks_Dec.__bases__ = tuple(bases) - - ns0.DefragmentAllDisksRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DefragmentAllDisks_Dec_Holder" - - class DefragmentAllDisksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DefragmentAllDisksResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DefragmentAllDisksResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DefragmentAllDisksResponse") - kw["aname"] = "_DefragmentAllDisksResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DefragmentAllDisksResponse_Holder" - self.pyclass = Holder - - class CreateSecondaryVM_Dec(ElementDeclaration): - literal = "CreateSecondaryVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateSecondaryVM") - kw["aname"] = "_CreateSecondaryVM" - if ns0.CreateSecondaryVMRequestType_Def not in ns0.CreateSecondaryVM_Dec.__bases__: - bases = list(ns0.CreateSecondaryVM_Dec.__bases__) - bases.insert(0, ns0.CreateSecondaryVMRequestType_Def) - ns0.CreateSecondaryVM_Dec.__bases__ = tuple(bases) - - ns0.CreateSecondaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateSecondaryVM_Dec_Holder" - - class CreateSecondaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateSecondaryVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateSecondaryVMResponse_Dec.schema - TClist = [GTD("urn:vim25","FaultToleranceSecondaryOpResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateSecondaryVMResponse") - kw["aname"] = "_CreateSecondaryVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateSecondaryVMResponse_Holder" - self.pyclass = Holder - - class CreateSecondaryVM_Task_Dec(ElementDeclaration): - literal = "CreateSecondaryVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateSecondaryVM_Task") - kw["aname"] = "_CreateSecondaryVM_Task" - if ns0.CreateSecondaryVMRequestType_Def not in ns0.CreateSecondaryVM_Task_Dec.__bases__: - bases = list(ns0.CreateSecondaryVM_Task_Dec.__bases__) - bases.insert(0, ns0.CreateSecondaryVMRequestType_Def) - ns0.CreateSecondaryVM_Task_Dec.__bases__ = tuple(bases) - - ns0.CreateSecondaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateSecondaryVM_Task_Dec_Holder" - - class CreateSecondaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateSecondaryVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateSecondaryVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateSecondaryVM_TaskResponse") - kw["aname"] = "_CreateSecondaryVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateSecondaryVM_TaskResponse_Holder" - self.pyclass = Holder - - class TurnOffFaultToleranceForVM_Dec(ElementDeclaration): - literal = "TurnOffFaultToleranceForVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVM") - kw["aname"] = "_TurnOffFaultToleranceForVM" - if ns0.TurnOffFaultToleranceForVMRequestType_Def not in ns0.TurnOffFaultToleranceForVM_Dec.__bases__: - bases = list(ns0.TurnOffFaultToleranceForVM_Dec.__bases__) - bases.insert(0, ns0.TurnOffFaultToleranceForVMRequestType_Def) - ns0.TurnOffFaultToleranceForVM_Dec.__bases__ = tuple(bases) - - ns0.TurnOffFaultToleranceForVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TurnOffFaultToleranceForVM_Dec_Holder" - - class TurnOffFaultToleranceForVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "TurnOffFaultToleranceForVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.TurnOffFaultToleranceForVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVMResponse") - kw["aname"] = "_TurnOffFaultToleranceForVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "TurnOffFaultToleranceForVMResponse_Holder" - self.pyclass = Holder - - class TurnOffFaultToleranceForVM_Task_Dec(ElementDeclaration): - literal = "TurnOffFaultToleranceForVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVM_Task") - kw["aname"] = "_TurnOffFaultToleranceForVM_Task" - if ns0.TurnOffFaultToleranceForVMRequestType_Def not in ns0.TurnOffFaultToleranceForVM_Task_Dec.__bases__: - bases = list(ns0.TurnOffFaultToleranceForVM_Task_Dec.__bases__) - bases.insert(0, ns0.TurnOffFaultToleranceForVMRequestType_Def) - ns0.TurnOffFaultToleranceForVM_Task_Dec.__bases__ = tuple(bases) - - ns0.TurnOffFaultToleranceForVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TurnOffFaultToleranceForVM_Task_Dec_Holder" - - class TurnOffFaultToleranceForVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "TurnOffFaultToleranceForVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.TurnOffFaultToleranceForVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","TurnOffFaultToleranceForVM_TaskResponse") - kw["aname"] = "_TurnOffFaultToleranceForVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "TurnOffFaultToleranceForVM_TaskResponse_Holder" - self.pyclass = Holder - - class MakePrimaryVM_Dec(ElementDeclaration): - literal = "MakePrimaryVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MakePrimaryVM") - kw["aname"] = "_MakePrimaryVM" - if ns0.MakePrimaryVMRequestType_Def not in ns0.MakePrimaryVM_Dec.__bases__: - bases = list(ns0.MakePrimaryVM_Dec.__bases__) - bases.insert(0, ns0.MakePrimaryVMRequestType_Def) - ns0.MakePrimaryVM_Dec.__bases__ = tuple(bases) - - ns0.MakePrimaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MakePrimaryVM_Dec_Holder" - - class MakePrimaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MakePrimaryVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MakePrimaryVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","MakePrimaryVMResponse") - kw["aname"] = "_MakePrimaryVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "MakePrimaryVMResponse_Holder" - self.pyclass = Holder - - class MakePrimaryVM_Task_Dec(ElementDeclaration): - literal = "MakePrimaryVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MakePrimaryVM_Task") - kw["aname"] = "_MakePrimaryVM_Task" - if ns0.MakePrimaryVMRequestType_Def not in ns0.MakePrimaryVM_Task_Dec.__bases__: - bases = list(ns0.MakePrimaryVM_Task_Dec.__bases__) - bases.insert(0, ns0.MakePrimaryVMRequestType_Def) - ns0.MakePrimaryVM_Task_Dec.__bases__ = tuple(bases) - - ns0.MakePrimaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MakePrimaryVM_Task_Dec_Holder" - - class MakePrimaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "MakePrimaryVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.MakePrimaryVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","MakePrimaryVM_TaskResponse") - kw["aname"] = "_MakePrimaryVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "MakePrimaryVM_TaskResponse_Holder" - self.pyclass = Holder - - class TerminateFaultTolerantVM_Dec(ElementDeclaration): - literal = "TerminateFaultTolerantVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TerminateFaultTolerantVM") - kw["aname"] = "_TerminateFaultTolerantVM" - if ns0.TerminateFaultTolerantVMRequestType_Def not in ns0.TerminateFaultTolerantVM_Dec.__bases__: - bases = list(ns0.TerminateFaultTolerantVM_Dec.__bases__) - bases.insert(0, ns0.TerminateFaultTolerantVMRequestType_Def) - ns0.TerminateFaultTolerantVM_Dec.__bases__ = tuple(bases) - - ns0.TerminateFaultTolerantVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TerminateFaultTolerantVM_Dec_Holder" - - class TerminateFaultTolerantVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "TerminateFaultTolerantVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.TerminateFaultTolerantVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","TerminateFaultTolerantVMResponse") - kw["aname"] = "_TerminateFaultTolerantVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "TerminateFaultTolerantVMResponse_Holder" - self.pyclass = Holder - - class TerminateFaultTolerantVM_Task_Dec(ElementDeclaration): - literal = "TerminateFaultTolerantVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TerminateFaultTolerantVM_Task") - kw["aname"] = "_TerminateFaultTolerantVM_Task" - if ns0.TerminateFaultTolerantVMRequestType_Def not in ns0.TerminateFaultTolerantVM_Task_Dec.__bases__: - bases = list(ns0.TerminateFaultTolerantVM_Task_Dec.__bases__) - bases.insert(0, ns0.TerminateFaultTolerantVMRequestType_Def) - ns0.TerminateFaultTolerantVM_Task_Dec.__bases__ = tuple(bases) - - ns0.TerminateFaultTolerantVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TerminateFaultTolerantVM_Task_Dec_Holder" - - class TerminateFaultTolerantVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "TerminateFaultTolerantVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.TerminateFaultTolerantVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","TerminateFaultTolerantVM_TaskResponse") - kw["aname"] = "_TerminateFaultTolerantVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "TerminateFaultTolerantVM_TaskResponse_Holder" - self.pyclass = Holder - - class DisableSecondaryVM_Dec(ElementDeclaration): - literal = "DisableSecondaryVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisableSecondaryVM") - kw["aname"] = "_DisableSecondaryVM" - if ns0.DisableSecondaryVMRequestType_Def not in ns0.DisableSecondaryVM_Dec.__bases__: - bases = list(ns0.DisableSecondaryVM_Dec.__bases__) - bases.insert(0, ns0.DisableSecondaryVMRequestType_Def) - ns0.DisableSecondaryVM_Dec.__bases__ = tuple(bases) - - ns0.DisableSecondaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisableSecondaryVM_Dec_Holder" - - class DisableSecondaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisableSecondaryVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisableSecondaryVMResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DisableSecondaryVMResponse") - kw["aname"] = "_DisableSecondaryVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DisableSecondaryVMResponse_Holder" - self.pyclass = Holder - - class DisableSecondaryVM_Task_Dec(ElementDeclaration): - literal = "DisableSecondaryVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisableSecondaryVM_Task") - kw["aname"] = "_DisableSecondaryVM_Task" - if ns0.DisableSecondaryVMRequestType_Def not in ns0.DisableSecondaryVM_Task_Dec.__bases__: - bases = list(ns0.DisableSecondaryVM_Task_Dec.__bases__) - bases.insert(0, ns0.DisableSecondaryVMRequestType_Def) - ns0.DisableSecondaryVM_Task_Dec.__bases__ = tuple(bases) - - ns0.DisableSecondaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisableSecondaryVM_Task_Dec_Holder" - - class DisableSecondaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisableSecondaryVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisableSecondaryVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DisableSecondaryVM_TaskResponse") - kw["aname"] = "_DisableSecondaryVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DisableSecondaryVM_TaskResponse_Holder" - self.pyclass = Holder - - class EnableSecondaryVM_Dec(ElementDeclaration): - literal = "EnableSecondaryVM" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnableSecondaryVM") - kw["aname"] = "_EnableSecondaryVM" - if ns0.EnableSecondaryVMRequestType_Def not in ns0.EnableSecondaryVM_Dec.__bases__: - bases = list(ns0.EnableSecondaryVM_Dec.__bases__) - bases.insert(0, ns0.EnableSecondaryVMRequestType_Def) - ns0.EnableSecondaryVM_Dec.__bases__ = tuple(bases) - - ns0.EnableSecondaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnableSecondaryVM_Dec_Holder" - - class EnableSecondaryVMResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnableSecondaryVMResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnableSecondaryVMResponse_Dec.schema - TClist = [GTD("urn:vim25","FaultToleranceSecondaryOpResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","EnableSecondaryVMResponse") - kw["aname"] = "_EnableSecondaryVMResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "EnableSecondaryVMResponse_Holder" - self.pyclass = Holder - - class EnableSecondaryVM_Task_Dec(ElementDeclaration): - literal = "EnableSecondaryVM_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnableSecondaryVM_Task") - kw["aname"] = "_EnableSecondaryVM_Task" - if ns0.EnableSecondaryVMRequestType_Def not in ns0.EnableSecondaryVM_Task_Dec.__bases__: - bases = list(ns0.EnableSecondaryVM_Task_Dec.__bases__) - bases.insert(0, ns0.EnableSecondaryVMRequestType_Def) - ns0.EnableSecondaryVM_Task_Dec.__bases__ = tuple(bases) - - ns0.EnableSecondaryVMRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnableSecondaryVM_Task_Dec_Holder" - - class EnableSecondaryVM_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnableSecondaryVM_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnableSecondaryVM_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","EnableSecondaryVM_TaskResponse") - kw["aname"] = "_EnableSecondaryVM_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "EnableSecondaryVM_TaskResponse_Holder" - self.pyclass = Holder - - class SetDisplayTopology_Dec(ElementDeclaration): - literal = "SetDisplayTopology" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetDisplayTopology") - kw["aname"] = "_SetDisplayTopology" - if ns0.SetDisplayTopologyRequestType_Def not in ns0.SetDisplayTopology_Dec.__bases__: - bases = list(ns0.SetDisplayTopology_Dec.__bases__) - bases.insert(0, ns0.SetDisplayTopologyRequestType_Def) - ns0.SetDisplayTopology_Dec.__bases__ = tuple(bases) - - ns0.SetDisplayTopologyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetDisplayTopology_Dec_Holder" - - class SetDisplayTopologyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetDisplayTopologyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetDisplayTopologyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetDisplayTopologyResponse") - kw["aname"] = "_SetDisplayTopologyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetDisplayTopologyResponse_Holder" - self.pyclass = Holder - - class StartRecording_Dec(ElementDeclaration): - literal = "StartRecording" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StartRecording") - kw["aname"] = "_StartRecording" - if ns0.StartRecordingRequestType_Def not in ns0.StartRecording_Dec.__bases__: - bases = list(ns0.StartRecording_Dec.__bases__) - bases.insert(0, ns0.StartRecordingRequestType_Def) - ns0.StartRecording_Dec.__bases__ = tuple(bases) - - ns0.StartRecordingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StartRecording_Dec_Holder" - - class StartRecordingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StartRecordingResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StartRecordingResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","StartRecordingResponse") - kw["aname"] = "_StartRecordingResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "StartRecordingResponse_Holder" - self.pyclass = Holder - - class StartRecording_Task_Dec(ElementDeclaration): - literal = "StartRecording_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StartRecording_Task") - kw["aname"] = "_StartRecording_Task" - if ns0.StartRecordingRequestType_Def not in ns0.StartRecording_Task_Dec.__bases__: - bases = list(ns0.StartRecording_Task_Dec.__bases__) - bases.insert(0, ns0.StartRecordingRequestType_Def) - ns0.StartRecording_Task_Dec.__bases__ = tuple(bases) - - ns0.StartRecordingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StartRecording_Task_Dec_Holder" - - class StartRecording_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StartRecording_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StartRecording_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","StartRecording_TaskResponse") - kw["aname"] = "_StartRecording_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "StartRecording_TaskResponse_Holder" - self.pyclass = Holder - - class StopRecording_Dec(ElementDeclaration): - literal = "StopRecording" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StopRecording") - kw["aname"] = "_StopRecording" - if ns0.StopRecordingRequestType_Def not in ns0.StopRecording_Dec.__bases__: - bases = list(ns0.StopRecording_Dec.__bases__) - bases.insert(0, ns0.StopRecordingRequestType_Def) - ns0.StopRecording_Dec.__bases__ = tuple(bases) - - ns0.StopRecordingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StopRecording_Dec_Holder" - - class StopRecordingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StopRecordingResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StopRecordingResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","StopRecordingResponse") - kw["aname"] = "_StopRecordingResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "StopRecordingResponse_Holder" - self.pyclass = Holder - - class StopRecording_Task_Dec(ElementDeclaration): - literal = "StopRecording_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StopRecording_Task") - kw["aname"] = "_StopRecording_Task" - if ns0.StopRecordingRequestType_Def not in ns0.StopRecording_Task_Dec.__bases__: - bases = list(ns0.StopRecording_Task_Dec.__bases__) - bases.insert(0, ns0.StopRecordingRequestType_Def) - ns0.StopRecording_Task_Dec.__bases__ = tuple(bases) - - ns0.StopRecordingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StopRecording_Task_Dec_Holder" - - class StopRecording_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StopRecording_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StopRecording_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","StopRecording_TaskResponse") - kw["aname"] = "_StopRecording_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "StopRecording_TaskResponse_Holder" - self.pyclass = Holder - - class StartReplaying_Dec(ElementDeclaration): - literal = "StartReplaying" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StartReplaying") - kw["aname"] = "_StartReplaying" - if ns0.StartReplayingRequestType_Def not in ns0.StartReplaying_Dec.__bases__: - bases = list(ns0.StartReplaying_Dec.__bases__) - bases.insert(0, ns0.StartReplayingRequestType_Def) - ns0.StartReplaying_Dec.__bases__ = tuple(bases) - - ns0.StartReplayingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StartReplaying_Dec_Holder" - - class StartReplayingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StartReplayingResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StartReplayingResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","StartReplayingResponse") - kw["aname"] = "_StartReplayingResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "StartReplayingResponse_Holder" - self.pyclass = Holder - - class StartReplaying_Task_Dec(ElementDeclaration): - literal = "StartReplaying_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StartReplaying_Task") - kw["aname"] = "_StartReplaying_Task" - if ns0.StartReplayingRequestType_Def not in ns0.StartReplaying_Task_Dec.__bases__: - bases = list(ns0.StartReplaying_Task_Dec.__bases__) - bases.insert(0, ns0.StartReplayingRequestType_Def) - ns0.StartReplaying_Task_Dec.__bases__ = tuple(bases) - - ns0.StartReplayingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StartReplaying_Task_Dec_Holder" - - class StartReplaying_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StartReplaying_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StartReplaying_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","StartReplaying_TaskResponse") - kw["aname"] = "_StartReplaying_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "StartReplaying_TaskResponse_Holder" - self.pyclass = Holder - - class StopReplaying_Dec(ElementDeclaration): - literal = "StopReplaying" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StopReplaying") - kw["aname"] = "_StopReplaying" - if ns0.StopReplayingRequestType_Def not in ns0.StopReplaying_Dec.__bases__: - bases = list(ns0.StopReplaying_Dec.__bases__) - bases.insert(0, ns0.StopReplayingRequestType_Def) - ns0.StopReplaying_Dec.__bases__ = tuple(bases) - - ns0.StopReplayingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StopReplaying_Dec_Holder" - - class StopReplayingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StopReplayingResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StopReplayingResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","StopReplayingResponse") - kw["aname"] = "_StopReplayingResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "StopReplayingResponse_Holder" - self.pyclass = Holder - - class StopReplaying_Task_Dec(ElementDeclaration): - literal = "StopReplaying_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StopReplaying_Task") - kw["aname"] = "_StopReplaying_Task" - if ns0.StopReplayingRequestType_Def not in ns0.StopReplaying_Task_Dec.__bases__: - bases = list(ns0.StopReplaying_Task_Dec.__bases__) - bases.insert(0, ns0.StopReplayingRequestType_Def) - ns0.StopReplaying_Task_Dec.__bases__ = tuple(bases) - - ns0.StopReplayingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StopReplaying_Task_Dec_Holder" - - class StopReplaying_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StopReplaying_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StopReplaying_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","StopReplaying_TaskResponse") - kw["aname"] = "_StopReplaying_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "StopReplaying_TaskResponse_Holder" - self.pyclass = Holder - - class PromoteDisks_Dec(ElementDeclaration): - literal = "PromoteDisks" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PromoteDisks") - kw["aname"] = "_PromoteDisks" - if ns0.PromoteDisksRequestType_Def not in ns0.PromoteDisks_Dec.__bases__: - bases = list(ns0.PromoteDisks_Dec.__bases__) - bases.insert(0, ns0.PromoteDisksRequestType_Def) - ns0.PromoteDisks_Dec.__bases__ = tuple(bases) - - ns0.PromoteDisksRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PromoteDisks_Dec_Holder" - - class PromoteDisksResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PromoteDisksResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PromoteDisksResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PromoteDisksResponse") - kw["aname"] = "_PromoteDisksResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PromoteDisksResponse_Holder" - self.pyclass = Holder - - class PromoteDisks_Task_Dec(ElementDeclaration): - literal = "PromoteDisks_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PromoteDisks_Task") - kw["aname"] = "_PromoteDisks_Task" - if ns0.PromoteDisksRequestType_Def not in ns0.PromoteDisks_Task_Dec.__bases__: - bases = list(ns0.PromoteDisks_Task_Dec.__bases__) - bases.insert(0, ns0.PromoteDisksRequestType_Def) - ns0.PromoteDisks_Task_Dec.__bases__ = tuple(bases) - - ns0.PromoteDisksRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PromoteDisks_Task_Dec_Holder" - - class PromoteDisks_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PromoteDisks_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PromoteDisks_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","PromoteDisks_TaskResponse") - kw["aname"] = "_PromoteDisks_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "PromoteDisks_TaskResponse_Holder" - self.pyclass = Holder - - class CreateScreenshot_Dec(ElementDeclaration): - literal = "CreateScreenshot" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateScreenshot") - kw["aname"] = "_CreateScreenshot" - if ns0.CreateScreenshotRequestType_Def not in ns0.CreateScreenshot_Dec.__bases__: - bases = list(ns0.CreateScreenshot_Dec.__bases__) - bases.insert(0, ns0.CreateScreenshotRequestType_Def) - ns0.CreateScreenshot_Dec.__bases__ = tuple(bases) - - ns0.CreateScreenshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateScreenshot_Dec_Holder" - - class CreateScreenshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateScreenshotResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateScreenshotResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateScreenshotResponse") - kw["aname"] = "_CreateScreenshotResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateScreenshotResponse_Holder" - self.pyclass = Holder - - class CreateScreenshot_Task_Dec(ElementDeclaration): - literal = "CreateScreenshot_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateScreenshot_Task") - kw["aname"] = "_CreateScreenshot_Task" - if ns0.CreateScreenshotRequestType_Def not in ns0.CreateScreenshot_Task_Dec.__bases__: - bases = list(ns0.CreateScreenshot_Task_Dec.__bases__) - bases.insert(0, ns0.CreateScreenshotRequestType_Def) - ns0.CreateScreenshot_Task_Dec.__bases__ = tuple(bases) - - ns0.CreateScreenshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateScreenshot_Task_Dec_Holder" - - class CreateScreenshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateScreenshot_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateScreenshot_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateScreenshot_TaskResponse") - kw["aname"] = "_CreateScreenshot_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateScreenshot_TaskResponse_Holder" - self.pyclass = Holder - - class QueryChangedDiskAreas_Dec(ElementDeclaration): - literal = "QueryChangedDiskAreas" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryChangedDiskAreas") - kw["aname"] = "_QueryChangedDiskAreas" - if ns0.QueryChangedDiskAreasRequestType_Def not in ns0.QueryChangedDiskAreas_Dec.__bases__: - bases = list(ns0.QueryChangedDiskAreas_Dec.__bases__) - bases.insert(0, ns0.QueryChangedDiskAreasRequestType_Def) - ns0.QueryChangedDiskAreas_Dec.__bases__ = tuple(bases) - - ns0.QueryChangedDiskAreasRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryChangedDiskAreas_Dec_Holder" - - class QueryChangedDiskAreasResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryChangedDiskAreasResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryChangedDiskAreasResponse_Dec.schema - TClist = [GTD("urn:vim25","DiskChangeInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryChangedDiskAreasResponse") - kw["aname"] = "_QueryChangedDiskAreasResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryChangedDiskAreasResponse_Holder" - self.pyclass = Holder - - class QueryUnownedFiles_Dec(ElementDeclaration): - literal = "QueryUnownedFiles" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryUnownedFiles") - kw["aname"] = "_QueryUnownedFiles" - if ns0.QueryUnownedFilesRequestType_Def not in ns0.QueryUnownedFiles_Dec.__bases__: - bases = list(ns0.QueryUnownedFiles_Dec.__bases__) - bases.insert(0, ns0.QueryUnownedFilesRequestType_Def) - ns0.QueryUnownedFiles_Dec.__bases__ = tuple(bases) - - ns0.QueryUnownedFilesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryUnownedFiles_Dec_Holder" - - class QueryUnownedFilesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryUnownedFilesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryUnownedFilesResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryUnownedFilesResponse") - kw["aname"] = "_QueryUnownedFilesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryUnownedFilesResponse_Holder" - self.pyclass = Holder - - class RemoveAlarm_Dec(ElementDeclaration): - literal = "RemoveAlarm" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveAlarm") - kw["aname"] = "_RemoveAlarm" - if ns0.RemoveAlarmRequestType_Def not in ns0.RemoveAlarm_Dec.__bases__: - bases = list(ns0.RemoveAlarm_Dec.__bases__) - bases.insert(0, ns0.RemoveAlarmRequestType_Def) - ns0.RemoveAlarm_Dec.__bases__ = tuple(bases) - - ns0.RemoveAlarmRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveAlarm_Dec_Holder" - - class RemoveAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveAlarmResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveAlarmResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveAlarmResponse") - kw["aname"] = "_RemoveAlarmResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveAlarmResponse_Holder" - self.pyclass = Holder - - class ReconfigureAlarm_Dec(ElementDeclaration): - literal = "ReconfigureAlarm" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureAlarm") - kw["aname"] = "_ReconfigureAlarm" - if ns0.ReconfigureAlarmRequestType_Def not in ns0.ReconfigureAlarm_Dec.__bases__: - bases = list(ns0.ReconfigureAlarm_Dec.__bases__) - bases.insert(0, ns0.ReconfigureAlarmRequestType_Def) - ns0.ReconfigureAlarm_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureAlarmRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureAlarm_Dec_Holder" - - class ReconfigureAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureAlarmResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureAlarmResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureAlarmResponse") - kw["aname"] = "_ReconfigureAlarmResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureAlarmResponse_Holder" - self.pyclass = Holder - - class CreateAlarm_Dec(ElementDeclaration): - literal = "CreateAlarm" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateAlarm") - kw["aname"] = "_CreateAlarm" - if ns0.CreateAlarmRequestType_Def not in ns0.CreateAlarm_Dec.__bases__: - bases = list(ns0.CreateAlarm_Dec.__bases__) - bases.insert(0, ns0.CreateAlarmRequestType_Def) - ns0.CreateAlarm_Dec.__bases__ = tuple(bases) - - ns0.CreateAlarmRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateAlarm_Dec_Holder" - - class CreateAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateAlarmResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateAlarmResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateAlarmResponse") - kw["aname"] = "_CreateAlarmResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateAlarmResponse_Holder" - self.pyclass = Holder - - class GetAlarm_Dec(ElementDeclaration): - literal = "GetAlarm" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GetAlarm") - kw["aname"] = "_GetAlarm" - if ns0.GetAlarmRequestType_Def not in ns0.GetAlarm_Dec.__bases__: - bases = list(ns0.GetAlarm_Dec.__bases__) - bases.insert(0, ns0.GetAlarmRequestType_Def) - ns0.GetAlarm_Dec.__bases__ = tuple(bases) - - ns0.GetAlarmRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GetAlarm_Dec_Holder" - - class GetAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GetAlarmResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GetAlarmResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GetAlarmResponse") - kw["aname"] = "_GetAlarmResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "GetAlarmResponse_Holder" - self.pyclass = Holder - - class GetAlarmActionsEnabled_Dec(ElementDeclaration): - literal = "GetAlarmActionsEnabled" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GetAlarmActionsEnabled") - kw["aname"] = "_GetAlarmActionsEnabled" - if ns0.GetAlarmActionsEnabledRequestType_Def not in ns0.GetAlarmActionsEnabled_Dec.__bases__: - bases = list(ns0.GetAlarmActionsEnabled_Dec.__bases__) - bases.insert(0, ns0.GetAlarmActionsEnabledRequestType_Def) - ns0.GetAlarmActionsEnabled_Dec.__bases__ = tuple(bases) - - ns0.GetAlarmActionsEnabledRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GetAlarmActionsEnabled_Dec_Holder" - - class GetAlarmActionsEnabledResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GetAlarmActionsEnabledResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GetAlarmActionsEnabledResponse_Dec.schema - TClist = [ZSI.TC.Boolean(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GetAlarmActionsEnabledResponse") - kw["aname"] = "_GetAlarmActionsEnabledResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "GetAlarmActionsEnabledResponse_Holder" - self.pyclass = Holder - - class SetAlarmActionsEnabled_Dec(ElementDeclaration): - literal = "SetAlarmActionsEnabled" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetAlarmActionsEnabled") - kw["aname"] = "_SetAlarmActionsEnabled" - if ns0.SetAlarmActionsEnabledRequestType_Def not in ns0.SetAlarmActionsEnabled_Dec.__bases__: - bases = list(ns0.SetAlarmActionsEnabled_Dec.__bases__) - bases.insert(0, ns0.SetAlarmActionsEnabledRequestType_Def) - ns0.SetAlarmActionsEnabled_Dec.__bases__ = tuple(bases) - - ns0.SetAlarmActionsEnabledRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetAlarmActionsEnabled_Dec_Holder" - - class SetAlarmActionsEnabledResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetAlarmActionsEnabledResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetAlarmActionsEnabledResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetAlarmActionsEnabledResponse") - kw["aname"] = "_SetAlarmActionsEnabledResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetAlarmActionsEnabledResponse_Holder" - self.pyclass = Holder - - class GetAlarmState_Dec(ElementDeclaration): - literal = "GetAlarmState" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GetAlarmState") - kw["aname"] = "_GetAlarmState" - if ns0.GetAlarmStateRequestType_Def not in ns0.GetAlarmState_Dec.__bases__: - bases = list(ns0.GetAlarmState_Dec.__bases__) - bases.insert(0, ns0.GetAlarmStateRequestType_Def) - ns0.GetAlarmState_Dec.__bases__ = tuple(bases) - - ns0.GetAlarmStateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GetAlarmState_Dec_Holder" - - class GetAlarmStateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "GetAlarmStateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.GetAlarmStateResponse_Dec.schema - TClist = [GTD("urn:vim25","AlarmState",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","GetAlarmStateResponse") - kw["aname"] = "_GetAlarmStateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "GetAlarmStateResponse_Holder" - self.pyclass = Holder - - class AcknowledgeAlarm_Dec(ElementDeclaration): - literal = "AcknowledgeAlarm" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AcknowledgeAlarm") - kw["aname"] = "_AcknowledgeAlarm" - if ns0.AcknowledgeAlarmRequestType_Def not in ns0.AcknowledgeAlarm_Dec.__bases__: - bases = list(ns0.AcknowledgeAlarm_Dec.__bases__) - bases.insert(0, ns0.AcknowledgeAlarmRequestType_Def) - ns0.AcknowledgeAlarm_Dec.__bases__ = tuple(bases) - - ns0.AcknowledgeAlarmRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AcknowledgeAlarm_Dec_Holder" - - class AcknowledgeAlarmResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AcknowledgeAlarmResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AcknowledgeAlarmResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AcknowledgeAlarmResponse") - kw["aname"] = "_AcknowledgeAlarmResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AcknowledgeAlarmResponse_Holder" - self.pyclass = Holder - - class DVPortgroupReconfigure_Dec(ElementDeclaration): - literal = "DVPortgroupReconfigure" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVPortgroupReconfigure") - kw["aname"] = "_DVPortgroupReconfigure" - if ns0.DVPortgroupReconfigureRequestType_Def not in ns0.DVPortgroupReconfigure_Dec.__bases__: - bases = list(ns0.DVPortgroupReconfigure_Dec.__bases__) - bases.insert(0, ns0.DVPortgroupReconfigureRequestType_Def) - ns0.DVPortgroupReconfigure_Dec.__bases__ = tuple(bases) - - ns0.DVPortgroupReconfigureRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVPortgroupReconfigure_Dec_Holder" - - class DVPortgroupReconfigureResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVPortgroupReconfigureResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVPortgroupReconfigureResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DVPortgroupReconfigureResponse") - kw["aname"] = "_DVPortgroupReconfigureResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DVPortgroupReconfigureResponse_Holder" - self.pyclass = Holder - - class DVSManagerQueryAvailableSwitchSpec_Dec(ElementDeclaration): - literal = "DVSManagerQueryAvailableSwitchSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSManagerQueryAvailableSwitchSpec") - kw["aname"] = "_DVSManagerQueryAvailableSwitchSpec" - if ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def not in ns0.DVSManagerQueryAvailableSwitchSpec_Dec.__bases__: - bases = list(ns0.DVSManagerQueryAvailableSwitchSpec_Dec.__bases__) - bases.insert(0, ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def) - ns0.DVSManagerQueryAvailableSwitchSpec_Dec.__bases__ = tuple(bases) - - ns0.DVSManagerQueryAvailableSwitchSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryAvailableSwitchSpec_Dec_Holder" - - class DVSManagerQueryAvailableSwitchSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSManagerQueryAvailableSwitchSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSManagerQueryAvailableSwitchSpecResponse_Dec.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchProductSpec",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSManagerQueryAvailableSwitchSpecResponse") - kw["aname"] = "_DVSManagerQueryAvailableSwitchSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "DVSManagerQueryAvailableSwitchSpecResponse_Holder" - self.pyclass = Holder - - class DVSManagerQueryCompatibleHostForNewDvs_Dec(ElementDeclaration): - literal = "DVSManagerQueryCompatibleHostForNewDvs" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForNewDvs") - kw["aname"] = "_DVSManagerQueryCompatibleHostForNewDvs" - if ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def not in ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec.__bases__: - bases = list(ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec.__bases__) - bases.insert(0, ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def) - ns0.DVSManagerQueryCompatibleHostForNewDvs_Dec.__bases__ = tuple(bases) - - ns0.DVSManagerQueryCompatibleHostForNewDvsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryCompatibleHostForNewDvs_Dec_Holder" - - class DVSManagerQueryCompatibleHostForNewDvsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSManagerQueryCompatibleHostForNewDvsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSManagerQueryCompatibleHostForNewDvsResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForNewDvsResponse") - kw["aname"] = "_DVSManagerQueryCompatibleHostForNewDvsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "DVSManagerQueryCompatibleHostForNewDvsResponse_Holder" - self.pyclass = Holder - - class DVSManagerQueryCompatibleHostForExistingDvs_Dec(ElementDeclaration): - literal = "DVSManagerQueryCompatibleHostForExistingDvs" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForExistingDvs") - kw["aname"] = "_DVSManagerQueryCompatibleHostForExistingDvs" - if ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def not in ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec.__bases__: - bases = list(ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec.__bases__) - bases.insert(0, ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def) - ns0.DVSManagerQueryCompatibleHostForExistingDvs_Dec.__bases__ = tuple(bases) - - ns0.DVSManagerQueryCompatibleHostForExistingDvsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryCompatibleHostForExistingDvs_Dec_Holder" - - class DVSManagerQueryCompatibleHostForExistingDvsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSManagerQueryCompatibleHostForExistingDvsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSManagerQueryCompatibleHostForExistingDvsResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostForExistingDvsResponse") - kw["aname"] = "_DVSManagerQueryCompatibleHostForExistingDvsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "DVSManagerQueryCompatibleHostForExistingDvsResponse_Holder" - self.pyclass = Holder - - class DVSManagerQueryCompatibleHostSpec_Dec(ElementDeclaration): - literal = "DVSManagerQueryCompatibleHostSpec" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostSpec") - kw["aname"] = "_DVSManagerQueryCompatibleHostSpec" - if ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def not in ns0.DVSManagerQueryCompatibleHostSpec_Dec.__bases__: - bases = list(ns0.DVSManagerQueryCompatibleHostSpec_Dec.__bases__) - bases.insert(0, ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def) - ns0.DVSManagerQueryCompatibleHostSpec_Dec.__bases__ = tuple(bases) - - ns0.DVSManagerQueryCompatibleHostSpecRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryCompatibleHostSpec_Dec_Holder" - - class DVSManagerQueryCompatibleHostSpecResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSManagerQueryCompatibleHostSpecResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSManagerQueryCompatibleHostSpecResponse_Dec.schema - TClist = [GTD("urn:vim25","DistributedVirtualSwitchHostProductSpec",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSManagerQueryCompatibleHostSpecResponse") - kw["aname"] = "_DVSManagerQueryCompatibleHostSpecResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "DVSManagerQueryCompatibleHostSpecResponse_Holder" - self.pyclass = Holder - - class DVSManagerQuerySwitchByUuid_Dec(ElementDeclaration): - literal = "DVSManagerQuerySwitchByUuid" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSManagerQuerySwitchByUuid") - kw["aname"] = "_DVSManagerQuerySwitchByUuid" - if ns0.DVSManagerQuerySwitchByUuidRequestType_Def not in ns0.DVSManagerQuerySwitchByUuid_Dec.__bases__: - bases = list(ns0.DVSManagerQuerySwitchByUuid_Dec.__bases__) - bases.insert(0, ns0.DVSManagerQuerySwitchByUuidRequestType_Def) - ns0.DVSManagerQuerySwitchByUuid_Dec.__bases__ = tuple(bases) - - ns0.DVSManagerQuerySwitchByUuidRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQuerySwitchByUuid_Dec_Holder" - - class DVSManagerQuerySwitchByUuidResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSManagerQuerySwitchByUuidResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSManagerQuerySwitchByUuidResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSManagerQuerySwitchByUuidResponse") - kw["aname"] = "_DVSManagerQuerySwitchByUuidResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DVSManagerQuerySwitchByUuidResponse_Holder" - self.pyclass = Holder - - class DVSManagerQueryDvsConfigTarget_Dec(ElementDeclaration): - literal = "DVSManagerQueryDvsConfigTarget" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DVSManagerQueryDvsConfigTarget") - kw["aname"] = "_DVSManagerQueryDvsConfigTarget" - if ns0.DVSManagerQueryDvsConfigTargetRequestType_Def not in ns0.DVSManagerQueryDvsConfigTarget_Dec.__bases__: - bases = list(ns0.DVSManagerQueryDvsConfigTarget_Dec.__bases__) - bases.insert(0, ns0.DVSManagerQueryDvsConfigTargetRequestType_Def) - ns0.DVSManagerQueryDvsConfigTarget_Dec.__bases__ = tuple(bases) - - ns0.DVSManagerQueryDvsConfigTargetRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DVSManagerQueryDvsConfigTarget_Dec_Holder" - - class DVSManagerQueryDvsConfigTargetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DVSManagerQueryDvsConfigTargetResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DVSManagerQueryDvsConfigTargetResponse_Dec.schema - TClist = [GTD("urn:vim25","DVSManagerDvsConfigTarget",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","DVSManagerQueryDvsConfigTargetResponse") - kw["aname"] = "_DVSManagerQueryDvsConfigTargetResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "DVSManagerQueryDvsConfigTargetResponse_Holder" - self.pyclass = Holder - - class ReadNextEvents_Dec(ElementDeclaration): - literal = "ReadNextEvents" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReadNextEvents") - kw["aname"] = "_ReadNextEvents" - if ns0.ReadNextEventsRequestType_Def not in ns0.ReadNextEvents_Dec.__bases__: - bases = list(ns0.ReadNextEvents_Dec.__bases__) - bases.insert(0, ns0.ReadNextEventsRequestType_Def) - ns0.ReadNextEvents_Dec.__bases__ = tuple(bases) - - ns0.ReadNextEventsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReadNextEvents_Dec_Holder" - - class ReadNextEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReadNextEventsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReadNextEventsResponse_Dec.schema - TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReadNextEventsResponse") - kw["aname"] = "_ReadNextEventsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ReadNextEventsResponse_Holder" - self.pyclass = Holder - - class ReadPreviousEvents_Dec(ElementDeclaration): - literal = "ReadPreviousEvents" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReadPreviousEvents") - kw["aname"] = "_ReadPreviousEvents" - if ns0.ReadPreviousEventsRequestType_Def not in ns0.ReadPreviousEvents_Dec.__bases__: - bases = list(ns0.ReadPreviousEvents_Dec.__bases__) - bases.insert(0, ns0.ReadPreviousEventsRequestType_Def) - ns0.ReadPreviousEvents_Dec.__bases__ = tuple(bases) - - ns0.ReadPreviousEventsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReadPreviousEvents_Dec_Holder" - - class ReadPreviousEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReadPreviousEventsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReadPreviousEventsResponse_Dec.schema - TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ReadPreviousEventsResponse") - kw["aname"] = "_ReadPreviousEventsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ReadPreviousEventsResponse_Holder" - self.pyclass = Holder - - class RetrieveArgumentDescription_Dec(ElementDeclaration): - literal = "RetrieveArgumentDescription" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveArgumentDescription") - kw["aname"] = "_RetrieveArgumentDescription" - if ns0.RetrieveArgumentDescriptionRequestType_Def not in ns0.RetrieveArgumentDescription_Dec.__bases__: - bases = list(ns0.RetrieveArgumentDescription_Dec.__bases__) - bases.insert(0, ns0.RetrieveArgumentDescriptionRequestType_Def) - ns0.RetrieveArgumentDescription_Dec.__bases__ = tuple(bases) - - ns0.RetrieveArgumentDescriptionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveArgumentDescription_Dec_Holder" - - class RetrieveArgumentDescriptionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveArgumentDescriptionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveArgumentDescriptionResponse_Dec.schema - TClist = [GTD("urn:vim25","EventArgDesc",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveArgumentDescriptionResponse") - kw["aname"] = "_RetrieveArgumentDescriptionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveArgumentDescriptionResponse_Holder" - self.pyclass = Holder - - class CreateCollectorForEvents_Dec(ElementDeclaration): - literal = "CreateCollectorForEvents" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateCollectorForEvents") - kw["aname"] = "_CreateCollectorForEvents" - if ns0.CreateCollectorForEventsRequestType_Def not in ns0.CreateCollectorForEvents_Dec.__bases__: - bases = list(ns0.CreateCollectorForEvents_Dec.__bases__) - bases.insert(0, ns0.CreateCollectorForEventsRequestType_Def) - ns0.CreateCollectorForEvents_Dec.__bases__ = tuple(bases) - - ns0.CreateCollectorForEventsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateCollectorForEvents_Dec_Holder" - - class CreateCollectorForEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateCollectorForEventsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateCollectorForEventsResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateCollectorForEventsResponse") - kw["aname"] = "_CreateCollectorForEventsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateCollectorForEventsResponse_Holder" - self.pyclass = Holder - - class LogUserEvent_Dec(ElementDeclaration): - literal = "LogUserEvent" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LogUserEvent") - kw["aname"] = "_LogUserEvent" - if ns0.LogUserEventRequestType_Def not in ns0.LogUserEvent_Dec.__bases__: - bases = list(ns0.LogUserEvent_Dec.__bases__) - bases.insert(0, ns0.LogUserEventRequestType_Def) - ns0.LogUserEvent_Dec.__bases__ = tuple(bases) - - ns0.LogUserEventRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LogUserEvent_Dec_Holder" - - class LogUserEventResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "LogUserEventResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.LogUserEventResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","LogUserEventResponse") - kw["aname"] = "_LogUserEventResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "LogUserEventResponse_Holder" - self.pyclass = Holder - - class QueryEvents_Dec(ElementDeclaration): - literal = "QueryEvents" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryEvents") - kw["aname"] = "_QueryEvents" - if ns0.QueryEventsRequestType_Def not in ns0.QueryEvents_Dec.__bases__: - bases = list(ns0.QueryEvents_Dec.__bases__) - bases.insert(0, ns0.QueryEventsRequestType_Def) - ns0.QueryEvents_Dec.__bases__ = tuple(bases) - - ns0.QueryEventsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryEvents_Dec_Holder" - - class QueryEventsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryEventsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryEventsResponse_Dec.schema - TClist = [GTD("urn:vim25","Event",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryEventsResponse") - kw["aname"] = "_QueryEventsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryEventsResponse_Holder" - self.pyclass = Holder - - class PostEvent_Dec(ElementDeclaration): - literal = "PostEvent" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PostEvent") - kw["aname"] = "_PostEvent" - if ns0.PostEventRequestType_Def not in ns0.PostEvent_Dec.__bases__: - bases = list(ns0.PostEvent_Dec.__bases__) - bases.insert(0, ns0.PostEventRequestType_Def) - ns0.PostEvent_Dec.__bases__ = tuple(bases) - - ns0.PostEventRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PostEvent_Dec_Holder" - - class PostEventResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "PostEventResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.PostEventResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","PostEventResponse") - kw["aname"] = "_PostEventResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "PostEventResponse_Holder" - self.pyclass = Holder - - class AdminDisabledFault_Dec(ElementDeclaration): - literal = "AdminDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AdminDisabledFault") - kw["aname"] = "_AdminDisabledFault" - if ns0.AdminDisabled_Def not in ns0.AdminDisabledFault_Dec.__bases__: - bases = list(ns0.AdminDisabledFault_Dec.__bases__) - bases.insert(0, ns0.AdminDisabled_Def) - ns0.AdminDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.AdminDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AdminDisabledFault_Dec_Holder" - - class AdminNotDisabledFault_Dec(ElementDeclaration): - literal = "AdminNotDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AdminNotDisabledFault") - kw["aname"] = "_AdminNotDisabledFault" - if ns0.AdminNotDisabled_Def not in ns0.AdminNotDisabledFault_Dec.__bases__: - bases = list(ns0.AdminNotDisabledFault_Dec.__bases__) - bases.insert(0, ns0.AdminNotDisabled_Def) - ns0.AdminNotDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.AdminNotDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AdminNotDisabledFault_Dec_Holder" - - class AffinityConfiguredFault_Dec(ElementDeclaration): - literal = "AffinityConfiguredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AffinityConfiguredFault") - kw["aname"] = "_AffinityConfiguredFault" - if ns0.AffinityConfigured_Def not in ns0.AffinityConfiguredFault_Dec.__bases__: - bases = list(ns0.AffinityConfiguredFault_Dec.__bases__) - bases.insert(0, ns0.AffinityConfigured_Def) - ns0.AffinityConfiguredFault_Dec.__bases__ = tuple(bases) - - ns0.AffinityConfigured_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AffinityConfiguredFault_Dec_Holder" - - class AgentInstallFailedFault_Dec(ElementDeclaration): - literal = "AgentInstallFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AgentInstallFailedFault") - kw["aname"] = "_AgentInstallFailedFault" - if ns0.AgentInstallFailed_Def not in ns0.AgentInstallFailedFault_Dec.__bases__: - bases = list(ns0.AgentInstallFailedFault_Dec.__bases__) - bases.insert(0, ns0.AgentInstallFailed_Def) - ns0.AgentInstallFailedFault_Dec.__bases__ = tuple(bases) - - ns0.AgentInstallFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AgentInstallFailedFault_Dec_Holder" - - class AlreadyBeingManagedFault_Dec(ElementDeclaration): - literal = "AlreadyBeingManagedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AlreadyBeingManagedFault") - kw["aname"] = "_AlreadyBeingManagedFault" - if ns0.AlreadyBeingManaged_Def not in ns0.AlreadyBeingManagedFault_Dec.__bases__: - bases = list(ns0.AlreadyBeingManagedFault_Dec.__bases__) - bases.insert(0, ns0.AlreadyBeingManaged_Def) - ns0.AlreadyBeingManagedFault_Dec.__bases__ = tuple(bases) - - ns0.AlreadyBeingManaged_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AlreadyBeingManagedFault_Dec_Holder" - - class AlreadyConnectedFault_Dec(ElementDeclaration): - literal = "AlreadyConnectedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AlreadyConnectedFault") - kw["aname"] = "_AlreadyConnectedFault" - if ns0.AlreadyConnected_Def not in ns0.AlreadyConnectedFault_Dec.__bases__: - bases = list(ns0.AlreadyConnectedFault_Dec.__bases__) - bases.insert(0, ns0.AlreadyConnected_Def) - ns0.AlreadyConnectedFault_Dec.__bases__ = tuple(bases) - - ns0.AlreadyConnected_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AlreadyConnectedFault_Dec_Holder" - - class AlreadyExistsFault_Dec(ElementDeclaration): - literal = "AlreadyExistsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AlreadyExistsFault") - kw["aname"] = "_AlreadyExistsFault" - if ns0.AlreadyExists_Def not in ns0.AlreadyExistsFault_Dec.__bases__: - bases = list(ns0.AlreadyExistsFault_Dec.__bases__) - bases.insert(0, ns0.AlreadyExists_Def) - ns0.AlreadyExistsFault_Dec.__bases__ = tuple(bases) - - ns0.AlreadyExists_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AlreadyExistsFault_Dec_Holder" - - class AlreadyUpgradedFault_Dec(ElementDeclaration): - literal = "AlreadyUpgradedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AlreadyUpgradedFault") - kw["aname"] = "_AlreadyUpgradedFault" - if ns0.AlreadyUpgraded_Def not in ns0.AlreadyUpgradedFault_Dec.__bases__: - bases = list(ns0.AlreadyUpgradedFault_Dec.__bases__) - bases.insert(0, ns0.AlreadyUpgraded_Def) - ns0.AlreadyUpgradedFault_Dec.__bases__ = tuple(bases) - - ns0.AlreadyUpgraded_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AlreadyUpgradedFault_Dec_Holder" - - class ApplicationQuiesceFaultFault_Dec(ElementDeclaration): - literal = "ApplicationQuiesceFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ApplicationQuiesceFaultFault") - kw["aname"] = "_ApplicationQuiesceFaultFault" - if ns0.ApplicationQuiesceFault_Def not in ns0.ApplicationQuiesceFaultFault_Dec.__bases__: - bases = list(ns0.ApplicationQuiesceFaultFault_Dec.__bases__) - bases.insert(0, ns0.ApplicationQuiesceFault_Def) - ns0.ApplicationQuiesceFaultFault_Dec.__bases__ = tuple(bases) - - ns0.ApplicationQuiesceFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ApplicationQuiesceFaultFault_Dec_Holder" - - class AuthMinimumAdminPermissionFault_Dec(ElementDeclaration): - literal = "AuthMinimumAdminPermissionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AuthMinimumAdminPermissionFault") - kw["aname"] = "_AuthMinimumAdminPermissionFault" - if ns0.AuthMinimumAdminPermission_Def not in ns0.AuthMinimumAdminPermissionFault_Dec.__bases__: - bases = list(ns0.AuthMinimumAdminPermissionFault_Dec.__bases__) - bases.insert(0, ns0.AuthMinimumAdminPermission_Def) - ns0.AuthMinimumAdminPermissionFault_Dec.__bases__ = tuple(bases) - - ns0.AuthMinimumAdminPermission_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AuthMinimumAdminPermissionFault_Dec_Holder" - - class CannotAccessFileFault_Dec(ElementDeclaration): - literal = "CannotAccessFileFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAccessFileFault") - kw["aname"] = "_CannotAccessFileFault" - if ns0.CannotAccessFile_Def not in ns0.CannotAccessFileFault_Dec.__bases__: - bases = list(ns0.CannotAccessFileFault_Dec.__bases__) - bases.insert(0, ns0.CannotAccessFile_Def) - ns0.CannotAccessFileFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAccessFile_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessFileFault_Dec_Holder" - - class CannotAccessLocalSourceFault_Dec(ElementDeclaration): - literal = "CannotAccessLocalSourceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAccessLocalSourceFault") - kw["aname"] = "_CannotAccessLocalSourceFault" - if ns0.CannotAccessLocalSource_Def not in ns0.CannotAccessLocalSourceFault_Dec.__bases__: - bases = list(ns0.CannotAccessLocalSourceFault_Dec.__bases__) - bases.insert(0, ns0.CannotAccessLocalSource_Def) - ns0.CannotAccessLocalSourceFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAccessLocalSource_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessLocalSourceFault_Dec_Holder" - - class CannotAccessNetworkFault_Dec(ElementDeclaration): - literal = "CannotAccessNetworkFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAccessNetworkFault") - kw["aname"] = "_CannotAccessNetworkFault" - if ns0.CannotAccessNetwork_Def not in ns0.CannotAccessNetworkFault_Dec.__bases__: - bases = list(ns0.CannotAccessNetworkFault_Dec.__bases__) - bases.insert(0, ns0.CannotAccessNetwork_Def) - ns0.CannotAccessNetworkFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAccessNetwork_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessNetworkFault_Dec_Holder" - - class CannotAccessVmComponentFault_Dec(ElementDeclaration): - literal = "CannotAccessVmComponentFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAccessVmComponentFault") - kw["aname"] = "_CannotAccessVmComponentFault" - if ns0.CannotAccessVmComponent_Def not in ns0.CannotAccessVmComponentFault_Dec.__bases__: - bases = list(ns0.CannotAccessVmComponentFault_Dec.__bases__) - bases.insert(0, ns0.CannotAccessVmComponent_Def) - ns0.CannotAccessVmComponentFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAccessVmComponent_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmComponentFault_Dec_Holder" - - class CannotAccessVmConfigFault_Dec(ElementDeclaration): - literal = "CannotAccessVmConfigFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAccessVmConfigFault") - kw["aname"] = "_CannotAccessVmConfigFault" - if ns0.CannotAccessVmConfig_Def not in ns0.CannotAccessVmConfigFault_Dec.__bases__: - bases = list(ns0.CannotAccessVmConfigFault_Dec.__bases__) - bases.insert(0, ns0.CannotAccessVmConfig_Def) - ns0.CannotAccessVmConfigFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAccessVmConfig_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmConfigFault_Dec_Holder" - - class CannotAccessVmDeviceFault_Dec(ElementDeclaration): - literal = "CannotAccessVmDeviceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAccessVmDeviceFault") - kw["aname"] = "_CannotAccessVmDeviceFault" - if ns0.CannotAccessVmDevice_Def not in ns0.CannotAccessVmDeviceFault_Dec.__bases__: - bases = list(ns0.CannotAccessVmDeviceFault_Dec.__bases__) - bases.insert(0, ns0.CannotAccessVmDevice_Def) - ns0.CannotAccessVmDeviceFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAccessVmDevice_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmDeviceFault_Dec_Holder" - - class CannotAccessVmDiskFault_Dec(ElementDeclaration): - literal = "CannotAccessVmDiskFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAccessVmDiskFault") - kw["aname"] = "_CannotAccessVmDiskFault" - if ns0.CannotAccessVmDisk_Def not in ns0.CannotAccessVmDiskFault_Dec.__bases__: - bases = list(ns0.CannotAccessVmDiskFault_Dec.__bases__) - bases.insert(0, ns0.CannotAccessVmDisk_Def) - ns0.CannotAccessVmDiskFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAccessVmDisk_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAccessVmDiskFault_Dec_Holder" - - class CannotAddHostWithFTVmAsStandaloneFault_Dec(ElementDeclaration): - literal = "CannotAddHostWithFTVmAsStandaloneFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAddHostWithFTVmAsStandaloneFault") - kw["aname"] = "_CannotAddHostWithFTVmAsStandaloneFault" - if ns0.CannotAddHostWithFTVmAsStandalone_Def not in ns0.CannotAddHostWithFTVmAsStandaloneFault_Dec.__bases__: - bases = list(ns0.CannotAddHostWithFTVmAsStandaloneFault_Dec.__bases__) - bases.insert(0, ns0.CannotAddHostWithFTVmAsStandalone_Def) - ns0.CannotAddHostWithFTVmAsStandaloneFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAddHostWithFTVmAsStandalone_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAddHostWithFTVmAsStandaloneFault_Dec_Holder" - - class CannotAddHostWithFTVmToDifferentClusterFault_Dec(ElementDeclaration): - literal = "CannotAddHostWithFTVmToDifferentClusterFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAddHostWithFTVmToDifferentClusterFault") - kw["aname"] = "_CannotAddHostWithFTVmToDifferentClusterFault" - if ns0.CannotAddHostWithFTVmToDifferentCluster_Def not in ns0.CannotAddHostWithFTVmToDifferentClusterFault_Dec.__bases__: - bases = list(ns0.CannotAddHostWithFTVmToDifferentClusterFault_Dec.__bases__) - bases.insert(0, ns0.CannotAddHostWithFTVmToDifferentCluster_Def) - ns0.CannotAddHostWithFTVmToDifferentClusterFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAddHostWithFTVmToDifferentCluster_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAddHostWithFTVmToDifferentClusterFault_Dec_Holder" - - class CannotAddHostWithFTVmToNonHAClusterFault_Dec(ElementDeclaration): - literal = "CannotAddHostWithFTVmToNonHAClusterFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotAddHostWithFTVmToNonHAClusterFault") - kw["aname"] = "_CannotAddHostWithFTVmToNonHAClusterFault" - if ns0.CannotAddHostWithFTVmToNonHACluster_Def not in ns0.CannotAddHostWithFTVmToNonHAClusterFault_Dec.__bases__: - bases = list(ns0.CannotAddHostWithFTVmToNonHAClusterFault_Dec.__bases__) - bases.insert(0, ns0.CannotAddHostWithFTVmToNonHACluster_Def) - ns0.CannotAddHostWithFTVmToNonHAClusterFault_Dec.__bases__ = tuple(bases) - - ns0.CannotAddHostWithFTVmToNonHACluster_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotAddHostWithFTVmToNonHAClusterFault_Dec_Holder" - - class CannotCreateFileFault_Dec(ElementDeclaration): - literal = "CannotCreateFileFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotCreateFileFault") - kw["aname"] = "_CannotCreateFileFault" - if ns0.CannotCreateFile_Def not in ns0.CannotCreateFileFault_Dec.__bases__: - bases = list(ns0.CannotCreateFileFault_Dec.__bases__) - bases.insert(0, ns0.CannotCreateFile_Def) - ns0.CannotCreateFileFault_Dec.__bases__ = tuple(bases) - - ns0.CannotCreateFile_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotCreateFileFault_Dec_Holder" - - class CannotDecryptPasswordsFault_Dec(ElementDeclaration): - literal = "CannotDecryptPasswordsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotDecryptPasswordsFault") - kw["aname"] = "_CannotDecryptPasswordsFault" - if ns0.CannotDecryptPasswords_Def not in ns0.CannotDecryptPasswordsFault_Dec.__bases__: - bases = list(ns0.CannotDecryptPasswordsFault_Dec.__bases__) - bases.insert(0, ns0.CannotDecryptPasswords_Def) - ns0.CannotDecryptPasswordsFault_Dec.__bases__ = tuple(bases) - - ns0.CannotDecryptPasswords_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotDecryptPasswordsFault_Dec_Holder" - - class CannotDeleteFileFault_Dec(ElementDeclaration): - literal = "CannotDeleteFileFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotDeleteFileFault") - kw["aname"] = "_CannotDeleteFileFault" - if ns0.CannotDeleteFile_Def not in ns0.CannotDeleteFileFault_Dec.__bases__: - bases = list(ns0.CannotDeleteFileFault_Dec.__bases__) - bases.insert(0, ns0.CannotDeleteFile_Def) - ns0.CannotDeleteFileFault_Dec.__bases__ = tuple(bases) - - ns0.CannotDeleteFile_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotDeleteFileFault_Dec_Holder" - - class CannotDisableSnapshotFault_Dec(ElementDeclaration): - literal = "CannotDisableSnapshotFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotDisableSnapshotFault") - kw["aname"] = "_CannotDisableSnapshotFault" - if ns0.CannotDisableSnapshot_Def not in ns0.CannotDisableSnapshotFault_Dec.__bases__: - bases = list(ns0.CannotDisableSnapshotFault_Dec.__bases__) - bases.insert(0, ns0.CannotDisableSnapshot_Def) - ns0.CannotDisableSnapshotFault_Dec.__bases__ = tuple(bases) - - ns0.CannotDisableSnapshot_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotDisableSnapshotFault_Dec_Holder" - - class CannotDisconnectHostWithFaultToleranceVmFault_Dec(ElementDeclaration): - literal = "CannotDisconnectHostWithFaultToleranceVmFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotDisconnectHostWithFaultToleranceVmFault") - kw["aname"] = "_CannotDisconnectHostWithFaultToleranceVmFault" - if ns0.CannotDisconnectHostWithFaultToleranceVm_Def not in ns0.CannotDisconnectHostWithFaultToleranceVmFault_Dec.__bases__: - bases = list(ns0.CannotDisconnectHostWithFaultToleranceVmFault_Dec.__bases__) - bases.insert(0, ns0.CannotDisconnectHostWithFaultToleranceVm_Def) - ns0.CannotDisconnectHostWithFaultToleranceVmFault_Dec.__bases__ = tuple(bases) - - ns0.CannotDisconnectHostWithFaultToleranceVm_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotDisconnectHostWithFaultToleranceVmFault_Dec_Holder" - - class CannotModifyConfigCpuRequirementsFault_Dec(ElementDeclaration): - literal = "CannotModifyConfigCpuRequirementsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotModifyConfigCpuRequirementsFault") - kw["aname"] = "_CannotModifyConfigCpuRequirementsFault" - if ns0.CannotModifyConfigCpuRequirements_Def not in ns0.CannotModifyConfigCpuRequirementsFault_Dec.__bases__: - bases = list(ns0.CannotModifyConfigCpuRequirementsFault_Dec.__bases__) - bases.insert(0, ns0.CannotModifyConfigCpuRequirements_Def) - ns0.CannotModifyConfigCpuRequirementsFault_Dec.__bases__ = tuple(bases) - - ns0.CannotModifyConfigCpuRequirements_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotModifyConfigCpuRequirementsFault_Dec_Holder" - - class CannotMoveFaultToleranceVmFault_Dec(ElementDeclaration): - literal = "CannotMoveFaultToleranceVmFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotMoveFaultToleranceVmFault") - kw["aname"] = "_CannotMoveFaultToleranceVmFault" - if ns0.CannotMoveFaultToleranceVm_Def not in ns0.CannotMoveFaultToleranceVmFault_Dec.__bases__: - bases = list(ns0.CannotMoveFaultToleranceVmFault_Dec.__bases__) - bases.insert(0, ns0.CannotMoveFaultToleranceVm_Def) - ns0.CannotMoveFaultToleranceVmFault_Dec.__bases__ = tuple(bases) - - ns0.CannotMoveFaultToleranceVm_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotMoveFaultToleranceVmFault_Dec_Holder" - - class CannotMoveHostWithFaultToleranceVmFault_Dec(ElementDeclaration): - literal = "CannotMoveHostWithFaultToleranceVmFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CannotMoveHostWithFaultToleranceVmFault") - kw["aname"] = "_CannotMoveHostWithFaultToleranceVmFault" - if ns0.CannotMoveHostWithFaultToleranceVm_Def not in ns0.CannotMoveHostWithFaultToleranceVmFault_Dec.__bases__: - bases = list(ns0.CannotMoveHostWithFaultToleranceVmFault_Dec.__bases__) - bases.insert(0, ns0.CannotMoveHostWithFaultToleranceVm_Def) - ns0.CannotMoveHostWithFaultToleranceVmFault_Dec.__bases__ = tuple(bases) - - ns0.CannotMoveHostWithFaultToleranceVm_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CannotMoveHostWithFaultToleranceVmFault_Dec_Holder" - - class CloneFromSnapshotNotSupportedFault_Dec(ElementDeclaration): - literal = "CloneFromSnapshotNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CloneFromSnapshotNotSupportedFault") - kw["aname"] = "_CloneFromSnapshotNotSupportedFault" - if ns0.CloneFromSnapshotNotSupported_Def not in ns0.CloneFromSnapshotNotSupportedFault_Dec.__bases__: - bases = list(ns0.CloneFromSnapshotNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.CloneFromSnapshotNotSupported_Def) - ns0.CloneFromSnapshotNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.CloneFromSnapshotNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CloneFromSnapshotNotSupportedFault_Dec_Holder" - - class ConcurrentAccessFault_Dec(ElementDeclaration): - literal = "ConcurrentAccessFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ConcurrentAccessFault") - kw["aname"] = "_ConcurrentAccessFault" - if ns0.ConcurrentAccess_Def not in ns0.ConcurrentAccessFault_Dec.__bases__: - bases = list(ns0.ConcurrentAccessFault_Dec.__bases__) - bases.insert(0, ns0.ConcurrentAccess_Def) - ns0.ConcurrentAccessFault_Dec.__bases__ = tuple(bases) - - ns0.ConcurrentAccess_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ConcurrentAccessFault_Dec_Holder" - - class ConnectedIsoFault_Dec(ElementDeclaration): - literal = "ConnectedIsoFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ConnectedIsoFault") - kw["aname"] = "_ConnectedIsoFault" - if ns0.ConnectedIso_Def not in ns0.ConnectedIsoFault_Dec.__bases__: - bases = list(ns0.ConnectedIsoFault_Dec.__bases__) - bases.insert(0, ns0.ConnectedIso_Def) - ns0.ConnectedIsoFault_Dec.__bases__ = tuple(bases) - - ns0.ConnectedIso_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ConnectedIsoFault_Dec_Holder" - - class CpuCompatibilityUnknownFault_Dec(ElementDeclaration): - literal = "CpuCompatibilityUnknownFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CpuCompatibilityUnknownFault") - kw["aname"] = "_CpuCompatibilityUnknownFault" - if ns0.CpuCompatibilityUnknown_Def not in ns0.CpuCompatibilityUnknownFault_Dec.__bases__: - bases = list(ns0.CpuCompatibilityUnknownFault_Dec.__bases__) - bases.insert(0, ns0.CpuCompatibilityUnknown_Def) - ns0.CpuCompatibilityUnknownFault_Dec.__bases__ = tuple(bases) - - ns0.CpuCompatibilityUnknown_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CpuCompatibilityUnknownFault_Dec_Holder" - - class CpuHotPlugNotSupportedFault_Dec(ElementDeclaration): - literal = "CpuHotPlugNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CpuHotPlugNotSupportedFault") - kw["aname"] = "_CpuHotPlugNotSupportedFault" - if ns0.CpuHotPlugNotSupported_Def not in ns0.CpuHotPlugNotSupportedFault_Dec.__bases__: - bases = list(ns0.CpuHotPlugNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.CpuHotPlugNotSupported_Def) - ns0.CpuHotPlugNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.CpuHotPlugNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CpuHotPlugNotSupportedFault_Dec_Holder" - - class CpuIncompatibleFault_Dec(ElementDeclaration): - literal = "CpuIncompatibleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CpuIncompatibleFault") - kw["aname"] = "_CpuIncompatibleFault" - if ns0.CpuIncompatible_Def not in ns0.CpuIncompatibleFault_Dec.__bases__: - bases = list(ns0.CpuIncompatibleFault_Dec.__bases__) - bases.insert(0, ns0.CpuIncompatible_Def) - ns0.CpuIncompatibleFault_Dec.__bases__ = tuple(bases) - - ns0.CpuIncompatible_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CpuIncompatibleFault_Dec_Holder" - - class CpuIncompatible1ECXFault_Dec(ElementDeclaration): - literal = "CpuIncompatible1ECXFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CpuIncompatible1ECXFault") - kw["aname"] = "_CpuIncompatible1ECXFault" - if ns0.CpuIncompatible1ECX_Def not in ns0.CpuIncompatible1ECXFault_Dec.__bases__: - bases = list(ns0.CpuIncompatible1ECXFault_Dec.__bases__) - bases.insert(0, ns0.CpuIncompatible1ECX_Def) - ns0.CpuIncompatible1ECXFault_Dec.__bases__ = tuple(bases) - - ns0.CpuIncompatible1ECX_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CpuIncompatible1ECXFault_Dec_Holder" - - class CpuIncompatible81EDXFault_Dec(ElementDeclaration): - literal = "CpuIncompatible81EDXFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CpuIncompatible81EDXFault") - kw["aname"] = "_CpuIncompatible81EDXFault" - if ns0.CpuIncompatible81EDX_Def not in ns0.CpuIncompatible81EDXFault_Dec.__bases__: - bases = list(ns0.CpuIncompatible81EDXFault_Dec.__bases__) - bases.insert(0, ns0.CpuIncompatible81EDX_Def) - ns0.CpuIncompatible81EDXFault_Dec.__bases__ = tuple(bases) - - ns0.CpuIncompatible81EDX_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CpuIncompatible81EDXFault_Dec_Holder" - - class CustomizationFaultFault_Dec(ElementDeclaration): - literal = "CustomizationFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CustomizationFaultFault") - kw["aname"] = "_CustomizationFaultFault" - if ns0.CustomizationFault_Def not in ns0.CustomizationFaultFault_Dec.__bases__: - bases = list(ns0.CustomizationFaultFault_Dec.__bases__) - bases.insert(0, ns0.CustomizationFault_Def) - ns0.CustomizationFaultFault_Dec.__bases__ = tuple(bases) - - ns0.CustomizationFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CustomizationFaultFault_Dec_Holder" - - class CustomizationPendingFault_Dec(ElementDeclaration): - literal = "CustomizationPendingFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CustomizationPendingFault") - kw["aname"] = "_CustomizationPendingFault" - if ns0.CustomizationPending_Def not in ns0.CustomizationPendingFault_Dec.__bases__: - bases = list(ns0.CustomizationPendingFault_Dec.__bases__) - bases.insert(0, ns0.CustomizationPending_Def) - ns0.CustomizationPendingFault_Dec.__bases__ = tuple(bases) - - ns0.CustomizationPending_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CustomizationPendingFault_Dec_Holder" - - class DasConfigFaultFault_Dec(ElementDeclaration): - literal = "DasConfigFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DasConfigFaultFault") - kw["aname"] = "_DasConfigFaultFault" - if ns0.DasConfigFault_Def not in ns0.DasConfigFaultFault_Dec.__bases__: - bases = list(ns0.DasConfigFaultFault_Dec.__bases__) - bases.insert(0, ns0.DasConfigFault_Def) - ns0.DasConfigFaultFault_Dec.__bases__ = tuple(bases) - - ns0.DasConfigFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DasConfigFaultFault_Dec_Holder" - - class DatabaseErrorFault_Dec(ElementDeclaration): - literal = "DatabaseErrorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DatabaseErrorFault") - kw["aname"] = "_DatabaseErrorFault" - if ns0.DatabaseError_Def not in ns0.DatabaseErrorFault_Dec.__bases__: - bases = list(ns0.DatabaseErrorFault_Dec.__bases__) - bases.insert(0, ns0.DatabaseError_Def) - ns0.DatabaseErrorFault_Dec.__bases__ = tuple(bases) - - ns0.DatabaseError_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DatabaseErrorFault_Dec_Holder" - - class DatacenterMismatchFault_Dec(ElementDeclaration): - literal = "DatacenterMismatchFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DatacenterMismatchFault") - kw["aname"] = "_DatacenterMismatchFault" - if ns0.DatacenterMismatch_Def not in ns0.DatacenterMismatchFault_Dec.__bases__: - bases = list(ns0.DatacenterMismatchFault_Dec.__bases__) - bases.insert(0, ns0.DatacenterMismatch_Def) - ns0.DatacenterMismatchFault_Dec.__bases__ = tuple(bases) - - ns0.DatacenterMismatch_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DatacenterMismatchFault_Dec_Holder" - - class DatastoreNotWritableOnHostFault_Dec(ElementDeclaration): - literal = "DatastoreNotWritableOnHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DatastoreNotWritableOnHostFault") - kw["aname"] = "_DatastoreNotWritableOnHostFault" - if ns0.DatastoreNotWritableOnHost_Def not in ns0.DatastoreNotWritableOnHostFault_Dec.__bases__: - bases = list(ns0.DatastoreNotWritableOnHostFault_Dec.__bases__) - bases.insert(0, ns0.DatastoreNotWritableOnHost_Def) - ns0.DatastoreNotWritableOnHostFault_Dec.__bases__ = tuple(bases) - - ns0.DatastoreNotWritableOnHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DatastoreNotWritableOnHostFault_Dec_Holder" - - class DestinationSwitchFullFault_Dec(ElementDeclaration): - literal = "DestinationSwitchFullFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestinationSwitchFullFault") - kw["aname"] = "_DestinationSwitchFullFault" - if ns0.DestinationSwitchFull_Def not in ns0.DestinationSwitchFullFault_Dec.__bases__: - bases = list(ns0.DestinationSwitchFullFault_Dec.__bases__) - bases.insert(0, ns0.DestinationSwitchFull_Def) - ns0.DestinationSwitchFullFault_Dec.__bases__ = tuple(bases) - - ns0.DestinationSwitchFull_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestinationSwitchFullFault_Dec_Holder" - - class DeviceBackingNotSupportedFault_Dec(ElementDeclaration): - literal = "DeviceBackingNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeviceBackingNotSupportedFault") - kw["aname"] = "_DeviceBackingNotSupportedFault" - if ns0.DeviceBackingNotSupported_Def not in ns0.DeviceBackingNotSupportedFault_Dec.__bases__: - bases = list(ns0.DeviceBackingNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.DeviceBackingNotSupported_Def) - ns0.DeviceBackingNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.DeviceBackingNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeviceBackingNotSupportedFault_Dec_Holder" - - class DeviceControllerNotSupportedFault_Dec(ElementDeclaration): - literal = "DeviceControllerNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeviceControllerNotSupportedFault") - kw["aname"] = "_DeviceControllerNotSupportedFault" - if ns0.DeviceControllerNotSupported_Def not in ns0.DeviceControllerNotSupportedFault_Dec.__bases__: - bases = list(ns0.DeviceControllerNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.DeviceControllerNotSupported_Def) - ns0.DeviceControllerNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.DeviceControllerNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeviceControllerNotSupportedFault_Dec_Holder" - - class DeviceHotPlugNotSupportedFault_Dec(ElementDeclaration): - literal = "DeviceHotPlugNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeviceHotPlugNotSupportedFault") - kw["aname"] = "_DeviceHotPlugNotSupportedFault" - if ns0.DeviceHotPlugNotSupported_Def not in ns0.DeviceHotPlugNotSupportedFault_Dec.__bases__: - bases = list(ns0.DeviceHotPlugNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.DeviceHotPlugNotSupported_Def) - ns0.DeviceHotPlugNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.DeviceHotPlugNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeviceHotPlugNotSupportedFault_Dec_Holder" - - class DeviceNotFoundFault_Dec(ElementDeclaration): - literal = "DeviceNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeviceNotFoundFault") - kw["aname"] = "_DeviceNotFoundFault" - if ns0.DeviceNotFound_Def not in ns0.DeviceNotFoundFault_Dec.__bases__: - bases = list(ns0.DeviceNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.DeviceNotFound_Def) - ns0.DeviceNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.DeviceNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeviceNotFoundFault_Dec_Holder" - - class DeviceNotSupportedFault_Dec(ElementDeclaration): - literal = "DeviceNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeviceNotSupportedFault") - kw["aname"] = "_DeviceNotSupportedFault" - if ns0.DeviceNotSupported_Def not in ns0.DeviceNotSupportedFault_Dec.__bases__: - bases = list(ns0.DeviceNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.DeviceNotSupported_Def) - ns0.DeviceNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.DeviceNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeviceNotSupportedFault_Dec_Holder" - - class DeviceUnsupportedForVmPlatformFault_Dec(ElementDeclaration): - literal = "DeviceUnsupportedForVmPlatformFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeviceUnsupportedForVmPlatformFault") - kw["aname"] = "_DeviceUnsupportedForVmPlatformFault" - if ns0.DeviceUnsupportedForVmPlatform_Def not in ns0.DeviceUnsupportedForVmPlatformFault_Dec.__bases__: - bases = list(ns0.DeviceUnsupportedForVmPlatformFault_Dec.__bases__) - bases.insert(0, ns0.DeviceUnsupportedForVmPlatform_Def) - ns0.DeviceUnsupportedForVmPlatformFault_Dec.__bases__ = tuple(bases) - - ns0.DeviceUnsupportedForVmPlatform_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeviceUnsupportedForVmPlatformFault_Dec_Holder" - - class DeviceUnsupportedForVmVersionFault_Dec(ElementDeclaration): - literal = "DeviceUnsupportedForVmVersionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeviceUnsupportedForVmVersionFault") - kw["aname"] = "_DeviceUnsupportedForVmVersionFault" - if ns0.DeviceUnsupportedForVmVersion_Def not in ns0.DeviceUnsupportedForVmVersionFault_Dec.__bases__: - bases = list(ns0.DeviceUnsupportedForVmVersionFault_Dec.__bases__) - bases.insert(0, ns0.DeviceUnsupportedForVmVersion_Def) - ns0.DeviceUnsupportedForVmVersionFault_Dec.__bases__ = tuple(bases) - - ns0.DeviceUnsupportedForVmVersion_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeviceUnsupportedForVmVersionFault_Dec_Holder" - - class DisableAdminNotSupportedFault_Dec(ElementDeclaration): - literal = "DisableAdminNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisableAdminNotSupportedFault") - kw["aname"] = "_DisableAdminNotSupportedFault" - if ns0.DisableAdminNotSupported_Def not in ns0.DisableAdminNotSupportedFault_Dec.__bases__: - bases = list(ns0.DisableAdminNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.DisableAdminNotSupported_Def) - ns0.DisableAdminNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.DisableAdminNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisableAdminNotSupportedFault_Dec_Holder" - - class DisallowedDiskModeChangeFault_Dec(ElementDeclaration): - literal = "DisallowedDiskModeChangeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisallowedDiskModeChangeFault") - kw["aname"] = "_DisallowedDiskModeChangeFault" - if ns0.DisallowedDiskModeChange_Def not in ns0.DisallowedDiskModeChangeFault_Dec.__bases__: - bases = list(ns0.DisallowedDiskModeChangeFault_Dec.__bases__) - bases.insert(0, ns0.DisallowedDiskModeChange_Def) - ns0.DisallowedDiskModeChangeFault_Dec.__bases__ = tuple(bases) - - ns0.DisallowedDiskModeChange_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisallowedDiskModeChangeFault_Dec_Holder" - - class DisallowedMigrationDeviceAttachedFault_Dec(ElementDeclaration): - literal = "DisallowedMigrationDeviceAttachedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisallowedMigrationDeviceAttachedFault") - kw["aname"] = "_DisallowedMigrationDeviceAttachedFault" - if ns0.DisallowedMigrationDeviceAttached_Def not in ns0.DisallowedMigrationDeviceAttachedFault_Dec.__bases__: - bases = list(ns0.DisallowedMigrationDeviceAttachedFault_Dec.__bases__) - bases.insert(0, ns0.DisallowedMigrationDeviceAttached_Def) - ns0.DisallowedMigrationDeviceAttachedFault_Dec.__bases__ = tuple(bases) - - ns0.DisallowedMigrationDeviceAttached_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisallowedMigrationDeviceAttachedFault_Dec_Holder" - - class DisallowedOperationOnFailoverHostFault_Dec(ElementDeclaration): - literal = "DisallowedOperationOnFailoverHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisallowedOperationOnFailoverHostFault") - kw["aname"] = "_DisallowedOperationOnFailoverHostFault" - if ns0.DisallowedOperationOnFailoverHost_Def not in ns0.DisallowedOperationOnFailoverHostFault_Dec.__bases__: - bases = list(ns0.DisallowedOperationOnFailoverHostFault_Dec.__bases__) - bases.insert(0, ns0.DisallowedOperationOnFailoverHost_Def) - ns0.DisallowedOperationOnFailoverHostFault_Dec.__bases__ = tuple(bases) - - ns0.DisallowedOperationOnFailoverHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisallowedOperationOnFailoverHostFault_Dec_Holder" - - class DiskMoveTypeNotSupportedFault_Dec(ElementDeclaration): - literal = "DiskMoveTypeNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DiskMoveTypeNotSupportedFault") - kw["aname"] = "_DiskMoveTypeNotSupportedFault" - if ns0.DiskMoveTypeNotSupported_Def not in ns0.DiskMoveTypeNotSupportedFault_Dec.__bases__: - bases = list(ns0.DiskMoveTypeNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.DiskMoveTypeNotSupported_Def) - ns0.DiskMoveTypeNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.DiskMoveTypeNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DiskMoveTypeNotSupportedFault_Dec_Holder" - - class DiskNotSupportedFault_Dec(ElementDeclaration): - literal = "DiskNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DiskNotSupportedFault") - kw["aname"] = "_DiskNotSupportedFault" - if ns0.DiskNotSupported_Def not in ns0.DiskNotSupportedFault_Dec.__bases__: - bases = list(ns0.DiskNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.DiskNotSupported_Def) - ns0.DiskNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.DiskNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DiskNotSupportedFault_Dec_Holder" - - class DrsDisabledOnVmFault_Dec(ElementDeclaration): - literal = "DrsDisabledOnVmFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DrsDisabledOnVmFault") - kw["aname"] = "_DrsDisabledOnVmFault" - if ns0.DrsDisabledOnVm_Def not in ns0.DrsDisabledOnVmFault_Dec.__bases__: - bases = list(ns0.DrsDisabledOnVmFault_Dec.__bases__) - bases.insert(0, ns0.DrsDisabledOnVm_Def) - ns0.DrsDisabledOnVmFault_Dec.__bases__ = tuple(bases) - - ns0.DrsDisabledOnVm_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DrsDisabledOnVmFault_Dec_Holder" - - class DrsVmotionIncompatibleFaultFault_Dec(ElementDeclaration): - literal = "DrsVmotionIncompatibleFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DrsVmotionIncompatibleFaultFault") - kw["aname"] = "_DrsVmotionIncompatibleFaultFault" - if ns0.DrsVmotionIncompatibleFault_Def not in ns0.DrsVmotionIncompatibleFaultFault_Dec.__bases__: - bases = list(ns0.DrsVmotionIncompatibleFaultFault_Dec.__bases__) - bases.insert(0, ns0.DrsVmotionIncompatibleFault_Def) - ns0.DrsVmotionIncompatibleFaultFault_Dec.__bases__ = tuple(bases) - - ns0.DrsVmotionIncompatibleFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DrsVmotionIncompatibleFaultFault_Dec_Holder" - - class DuplicateNameFault_Dec(ElementDeclaration): - literal = "DuplicateNameFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DuplicateNameFault") - kw["aname"] = "_DuplicateNameFault" - if ns0.DuplicateName_Def not in ns0.DuplicateNameFault_Dec.__bases__: - bases = list(ns0.DuplicateNameFault_Dec.__bases__) - bases.insert(0, ns0.DuplicateName_Def) - ns0.DuplicateNameFault_Dec.__bases__ = tuple(bases) - - ns0.DuplicateName_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DuplicateNameFault_Dec_Holder" - - class DvsFaultFault_Dec(ElementDeclaration): - literal = "DvsFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DvsFaultFault") - kw["aname"] = "_DvsFaultFault" - if ns0.DvsFault_Def not in ns0.DvsFaultFault_Dec.__bases__: - bases = list(ns0.DvsFaultFault_Dec.__bases__) - bases.insert(0, ns0.DvsFault_Def) - ns0.DvsFaultFault_Dec.__bases__ = tuple(bases) - - ns0.DvsFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DvsFaultFault_Dec_Holder" - - class DvsNotAuthorizedFault_Dec(ElementDeclaration): - literal = "DvsNotAuthorizedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DvsNotAuthorizedFault") - kw["aname"] = "_DvsNotAuthorizedFault" - if ns0.DvsNotAuthorized_Def not in ns0.DvsNotAuthorizedFault_Dec.__bases__: - bases = list(ns0.DvsNotAuthorizedFault_Dec.__bases__) - bases.insert(0, ns0.DvsNotAuthorized_Def) - ns0.DvsNotAuthorizedFault_Dec.__bases__ = tuple(bases) - - ns0.DvsNotAuthorized_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DvsNotAuthorizedFault_Dec_Holder" - - class DvsOperationBulkFaultFault_Dec(ElementDeclaration): - literal = "DvsOperationBulkFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DvsOperationBulkFaultFault") - kw["aname"] = "_DvsOperationBulkFaultFault" - if ns0.DvsOperationBulkFault_Def not in ns0.DvsOperationBulkFaultFault_Dec.__bases__: - bases = list(ns0.DvsOperationBulkFaultFault_Dec.__bases__) - bases.insert(0, ns0.DvsOperationBulkFault_Def) - ns0.DvsOperationBulkFaultFault_Dec.__bases__ = tuple(bases) - - ns0.DvsOperationBulkFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DvsOperationBulkFaultFault_Dec_Holder" - - class DvsScopeViolatedFault_Dec(ElementDeclaration): - literal = "DvsScopeViolatedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DvsScopeViolatedFault") - kw["aname"] = "_DvsScopeViolatedFault" - if ns0.DvsScopeViolated_Def not in ns0.DvsScopeViolatedFault_Dec.__bases__: - bases = list(ns0.DvsScopeViolatedFault_Dec.__bases__) - bases.insert(0, ns0.DvsScopeViolated_Def) - ns0.DvsScopeViolatedFault_Dec.__bases__ = tuple(bases) - - ns0.DvsScopeViolated_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DvsScopeViolatedFault_Dec_Holder" - - class EVCAdmissionFailedFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedFault") - kw["aname"] = "_EVCAdmissionFailedFault" - if ns0.EVCAdmissionFailed_Def not in ns0.EVCAdmissionFailedFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailed_Def) - ns0.EVCAdmissionFailedFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedFault_Dec_Holder" - - class EVCAdmissionFailedCPUFeaturesForModeFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedCPUFeaturesForModeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUFeaturesForModeFault") - kw["aname"] = "_EVCAdmissionFailedCPUFeaturesForModeFault" - if ns0.EVCAdmissionFailedCPUFeaturesForMode_Def not in ns0.EVCAdmissionFailedCPUFeaturesForModeFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUFeaturesForModeFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedCPUFeaturesForMode_Def) - ns0.EVCAdmissionFailedCPUFeaturesForModeFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedCPUFeaturesForMode_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUFeaturesForModeFault_Dec_Holder" - - class EVCAdmissionFailedCPUModelFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedCPUModelFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUModelFault") - kw["aname"] = "_EVCAdmissionFailedCPUModelFault" - if ns0.EVCAdmissionFailedCPUModel_Def not in ns0.EVCAdmissionFailedCPUModelFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUModelFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedCPUModel_Def) - ns0.EVCAdmissionFailedCPUModelFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedCPUModel_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUModelFault_Dec_Holder" - - class EVCAdmissionFailedCPUModelForModeFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedCPUModelForModeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUModelForModeFault") - kw["aname"] = "_EVCAdmissionFailedCPUModelForModeFault" - if ns0.EVCAdmissionFailedCPUModelForMode_Def not in ns0.EVCAdmissionFailedCPUModelForModeFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUModelForModeFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedCPUModelForMode_Def) - ns0.EVCAdmissionFailedCPUModelForModeFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedCPUModelForMode_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUModelForModeFault_Dec_Holder" - - class EVCAdmissionFailedCPUVendorFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedCPUVendorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUVendorFault") - kw["aname"] = "_EVCAdmissionFailedCPUVendorFault" - if ns0.EVCAdmissionFailedCPUVendor_Def not in ns0.EVCAdmissionFailedCPUVendorFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUVendorFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedCPUVendor_Def) - ns0.EVCAdmissionFailedCPUVendorFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedCPUVendor_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUVendorFault_Dec_Holder" - - class EVCAdmissionFailedCPUVendorUnknownFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedCPUVendorUnknownFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedCPUVendorUnknownFault") - kw["aname"] = "_EVCAdmissionFailedCPUVendorUnknownFault" - if ns0.EVCAdmissionFailedCPUVendorUnknown_Def not in ns0.EVCAdmissionFailedCPUVendorUnknownFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedCPUVendorUnknownFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedCPUVendorUnknown_Def) - ns0.EVCAdmissionFailedCPUVendorUnknownFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedCPUVendorUnknown_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedCPUVendorUnknownFault_Dec_Holder" - - class EVCAdmissionFailedHostDisconnectedFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedHostDisconnectedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedHostDisconnectedFault") - kw["aname"] = "_EVCAdmissionFailedHostDisconnectedFault" - if ns0.EVCAdmissionFailedHostDisconnected_Def not in ns0.EVCAdmissionFailedHostDisconnectedFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedHostDisconnectedFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedHostDisconnected_Def) - ns0.EVCAdmissionFailedHostDisconnectedFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedHostDisconnected_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedHostDisconnectedFault_Dec_Holder" - - class EVCAdmissionFailedHostSoftwareFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedHostSoftwareFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedHostSoftwareFault") - kw["aname"] = "_EVCAdmissionFailedHostSoftwareFault" - if ns0.EVCAdmissionFailedHostSoftware_Def not in ns0.EVCAdmissionFailedHostSoftwareFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedHostSoftwareFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedHostSoftware_Def) - ns0.EVCAdmissionFailedHostSoftwareFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedHostSoftware_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedHostSoftwareFault_Dec_Holder" - - class EVCAdmissionFailedHostSoftwareForModeFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedHostSoftwareForModeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedHostSoftwareForModeFault") - kw["aname"] = "_EVCAdmissionFailedHostSoftwareForModeFault" - if ns0.EVCAdmissionFailedHostSoftwareForMode_Def not in ns0.EVCAdmissionFailedHostSoftwareForModeFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedHostSoftwareForModeFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedHostSoftwareForMode_Def) - ns0.EVCAdmissionFailedHostSoftwareForModeFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedHostSoftwareForMode_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedHostSoftwareForModeFault_Dec_Holder" - - class EVCAdmissionFailedVmActiveFault_Dec(ElementDeclaration): - literal = "EVCAdmissionFailedVmActiveFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EVCAdmissionFailedVmActiveFault") - kw["aname"] = "_EVCAdmissionFailedVmActiveFault" - if ns0.EVCAdmissionFailedVmActive_Def not in ns0.EVCAdmissionFailedVmActiveFault_Dec.__bases__: - bases = list(ns0.EVCAdmissionFailedVmActiveFault_Dec.__bases__) - bases.insert(0, ns0.EVCAdmissionFailedVmActive_Def) - ns0.EVCAdmissionFailedVmActiveFault_Dec.__bases__ = tuple(bases) - - ns0.EVCAdmissionFailedVmActive_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EVCAdmissionFailedVmActiveFault_Dec_Holder" - - class EightHostLimitViolatedFault_Dec(ElementDeclaration): - literal = "EightHostLimitViolatedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EightHostLimitViolatedFault") - kw["aname"] = "_EightHostLimitViolatedFault" - if ns0.EightHostLimitViolated_Def not in ns0.EightHostLimitViolatedFault_Dec.__bases__: - bases = list(ns0.EightHostLimitViolatedFault_Dec.__bases__) - bases.insert(0, ns0.EightHostLimitViolated_Def) - ns0.EightHostLimitViolatedFault_Dec.__bases__ = tuple(bases) - - ns0.EightHostLimitViolated_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EightHostLimitViolatedFault_Dec_Holder" - - class ExpiredAddonLicenseFault_Dec(ElementDeclaration): - literal = "ExpiredAddonLicenseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExpiredAddonLicenseFault") - kw["aname"] = "_ExpiredAddonLicenseFault" - if ns0.ExpiredAddonLicense_Def not in ns0.ExpiredAddonLicenseFault_Dec.__bases__: - bases = list(ns0.ExpiredAddonLicenseFault_Dec.__bases__) - bases.insert(0, ns0.ExpiredAddonLicense_Def) - ns0.ExpiredAddonLicenseFault_Dec.__bases__ = tuple(bases) - - ns0.ExpiredAddonLicense_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExpiredAddonLicenseFault_Dec_Holder" - - class ExpiredEditionLicenseFault_Dec(ElementDeclaration): - literal = "ExpiredEditionLicenseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExpiredEditionLicenseFault") - kw["aname"] = "_ExpiredEditionLicenseFault" - if ns0.ExpiredEditionLicense_Def not in ns0.ExpiredEditionLicenseFault_Dec.__bases__: - bases = list(ns0.ExpiredEditionLicenseFault_Dec.__bases__) - bases.insert(0, ns0.ExpiredEditionLicense_Def) - ns0.ExpiredEditionLicenseFault_Dec.__bases__ = tuple(bases) - - ns0.ExpiredEditionLicense_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExpiredEditionLicenseFault_Dec_Holder" - - class ExpiredFeatureLicenseFault_Dec(ElementDeclaration): - literal = "ExpiredFeatureLicenseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExpiredFeatureLicenseFault") - kw["aname"] = "_ExpiredFeatureLicenseFault" - if ns0.ExpiredFeatureLicense_Def not in ns0.ExpiredFeatureLicenseFault_Dec.__bases__: - bases = list(ns0.ExpiredFeatureLicenseFault_Dec.__bases__) - bases.insert(0, ns0.ExpiredFeatureLicense_Def) - ns0.ExpiredFeatureLicenseFault_Dec.__bases__ = tuple(bases) - - ns0.ExpiredFeatureLicense_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExpiredFeatureLicenseFault_Dec_Holder" - - class ExtendedFaultFault_Dec(ElementDeclaration): - literal = "ExtendedFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExtendedFaultFault") - kw["aname"] = "_ExtendedFaultFault" - if ns0.ExtendedFault_Def not in ns0.ExtendedFaultFault_Dec.__bases__: - bases = list(ns0.ExtendedFaultFault_Dec.__bases__) - bases.insert(0, ns0.ExtendedFault_Def) - ns0.ExtendedFaultFault_Dec.__bases__ = tuple(bases) - - ns0.ExtendedFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExtendedFaultFault_Dec_Holder" - - class FaultToleranceAntiAffinityViolatedFault_Dec(ElementDeclaration): - literal = "FaultToleranceAntiAffinityViolatedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FaultToleranceAntiAffinityViolatedFault") - kw["aname"] = "_FaultToleranceAntiAffinityViolatedFault" - if ns0.FaultToleranceAntiAffinityViolated_Def not in ns0.FaultToleranceAntiAffinityViolatedFault_Dec.__bases__: - bases = list(ns0.FaultToleranceAntiAffinityViolatedFault_Dec.__bases__) - bases.insert(0, ns0.FaultToleranceAntiAffinityViolated_Def) - ns0.FaultToleranceAntiAffinityViolatedFault_Dec.__bases__ = tuple(bases) - - ns0.FaultToleranceAntiAffinityViolated_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceAntiAffinityViolatedFault_Dec_Holder" - - class FaultToleranceCpuIncompatibleFault_Dec(ElementDeclaration): - literal = "FaultToleranceCpuIncompatibleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FaultToleranceCpuIncompatibleFault") - kw["aname"] = "_FaultToleranceCpuIncompatibleFault" - if ns0.FaultToleranceCpuIncompatible_Def not in ns0.FaultToleranceCpuIncompatibleFault_Dec.__bases__: - bases = list(ns0.FaultToleranceCpuIncompatibleFault_Dec.__bases__) - bases.insert(0, ns0.FaultToleranceCpuIncompatible_Def) - ns0.FaultToleranceCpuIncompatibleFault_Dec.__bases__ = tuple(bases) - - ns0.FaultToleranceCpuIncompatible_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceCpuIncompatibleFault_Dec_Holder" - - class FaultToleranceNotLicensedFault_Dec(ElementDeclaration): - literal = "FaultToleranceNotLicensedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FaultToleranceNotLicensedFault") - kw["aname"] = "_FaultToleranceNotLicensedFault" - if ns0.FaultToleranceNotLicensed_Def not in ns0.FaultToleranceNotLicensedFault_Dec.__bases__: - bases = list(ns0.FaultToleranceNotLicensedFault_Dec.__bases__) - bases.insert(0, ns0.FaultToleranceNotLicensed_Def) - ns0.FaultToleranceNotLicensedFault_Dec.__bases__ = tuple(bases) - - ns0.FaultToleranceNotLicensed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceNotLicensedFault_Dec_Holder" - - class FaultToleranceNotSameBuildFault_Dec(ElementDeclaration): - literal = "FaultToleranceNotSameBuildFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FaultToleranceNotSameBuildFault") - kw["aname"] = "_FaultToleranceNotSameBuildFault" - if ns0.FaultToleranceNotSameBuild_Def not in ns0.FaultToleranceNotSameBuildFault_Dec.__bases__: - bases = list(ns0.FaultToleranceNotSameBuildFault_Dec.__bases__) - bases.insert(0, ns0.FaultToleranceNotSameBuild_Def) - ns0.FaultToleranceNotSameBuildFault_Dec.__bases__ = tuple(bases) - - ns0.FaultToleranceNotSameBuild_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FaultToleranceNotSameBuildFault_Dec_Holder" - - class FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec(ElementDeclaration): - literal = "FaultTolerancePrimaryPowerOnNotAttemptedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FaultTolerancePrimaryPowerOnNotAttemptedFault") - kw["aname"] = "_FaultTolerancePrimaryPowerOnNotAttemptedFault" - if ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def not in ns0.FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec.__bases__: - bases = list(ns0.FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec.__bases__) - bases.insert(0, ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def) - ns0.FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec.__bases__ = tuple(bases) - - ns0.FaultTolerancePrimaryPowerOnNotAttempted_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FaultTolerancePrimaryPowerOnNotAttemptedFault_Dec_Holder" - - class FileAlreadyExistsFault_Dec(ElementDeclaration): - literal = "FileAlreadyExistsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FileAlreadyExistsFault") - kw["aname"] = "_FileAlreadyExistsFault" - if ns0.FileAlreadyExists_Def not in ns0.FileAlreadyExistsFault_Dec.__bases__: - bases = list(ns0.FileAlreadyExistsFault_Dec.__bases__) - bases.insert(0, ns0.FileAlreadyExists_Def) - ns0.FileAlreadyExistsFault_Dec.__bases__ = tuple(bases) - - ns0.FileAlreadyExists_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FileAlreadyExistsFault_Dec_Holder" - - class FileBackedPortNotSupportedFault_Dec(ElementDeclaration): - literal = "FileBackedPortNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FileBackedPortNotSupportedFault") - kw["aname"] = "_FileBackedPortNotSupportedFault" - if ns0.FileBackedPortNotSupported_Def not in ns0.FileBackedPortNotSupportedFault_Dec.__bases__: - bases = list(ns0.FileBackedPortNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.FileBackedPortNotSupported_Def) - ns0.FileBackedPortNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.FileBackedPortNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FileBackedPortNotSupportedFault_Dec_Holder" - - class FileFaultFault_Dec(ElementDeclaration): - literal = "FileFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FileFaultFault") - kw["aname"] = "_FileFaultFault" - if ns0.FileFault_Def not in ns0.FileFaultFault_Dec.__bases__: - bases = list(ns0.FileFaultFault_Dec.__bases__) - bases.insert(0, ns0.FileFault_Def) - ns0.FileFaultFault_Dec.__bases__ = tuple(bases) - - ns0.FileFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FileFaultFault_Dec_Holder" - - class FileLockedFault_Dec(ElementDeclaration): - literal = "FileLockedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FileLockedFault") - kw["aname"] = "_FileLockedFault" - if ns0.FileLocked_Def not in ns0.FileLockedFault_Dec.__bases__: - bases = list(ns0.FileLockedFault_Dec.__bases__) - bases.insert(0, ns0.FileLocked_Def) - ns0.FileLockedFault_Dec.__bases__ = tuple(bases) - - ns0.FileLocked_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FileLockedFault_Dec_Holder" - - class FileNotFoundFault_Dec(ElementDeclaration): - literal = "FileNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FileNotFoundFault") - kw["aname"] = "_FileNotFoundFault" - if ns0.FileNotFound_Def not in ns0.FileNotFoundFault_Dec.__bases__: - bases = list(ns0.FileNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.FileNotFound_Def) - ns0.FileNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.FileNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FileNotFoundFault_Dec_Holder" - - class FileNotWritableFault_Dec(ElementDeclaration): - literal = "FileNotWritableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FileNotWritableFault") - kw["aname"] = "_FileNotWritableFault" - if ns0.FileNotWritable_Def not in ns0.FileNotWritableFault_Dec.__bases__: - bases = list(ns0.FileNotWritableFault_Dec.__bases__) - bases.insert(0, ns0.FileNotWritable_Def) - ns0.FileNotWritableFault_Dec.__bases__ = tuple(bases) - - ns0.FileNotWritable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FileNotWritableFault_Dec_Holder" - - class FileTooLargeFault_Dec(ElementDeclaration): - literal = "FileTooLargeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FileTooLargeFault") - kw["aname"] = "_FileTooLargeFault" - if ns0.FileTooLarge_Def not in ns0.FileTooLargeFault_Dec.__bases__: - bases = list(ns0.FileTooLargeFault_Dec.__bases__) - bases.insert(0, ns0.FileTooLarge_Def) - ns0.FileTooLargeFault_Dec.__bases__ = tuple(bases) - - ns0.FileTooLarge_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FileTooLargeFault_Dec_Holder" - - class FilesystemQuiesceFaultFault_Dec(ElementDeclaration): - literal = "FilesystemQuiesceFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FilesystemQuiesceFaultFault") - kw["aname"] = "_FilesystemQuiesceFaultFault" - if ns0.FilesystemQuiesceFault_Def not in ns0.FilesystemQuiesceFaultFault_Dec.__bases__: - bases = list(ns0.FilesystemQuiesceFaultFault_Dec.__bases__) - bases.insert(0, ns0.FilesystemQuiesceFault_Def) - ns0.FilesystemQuiesceFaultFault_Dec.__bases__ = tuple(bases) - - ns0.FilesystemQuiesceFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FilesystemQuiesceFaultFault_Dec_Holder" - - class FtIssuesOnHostFault_Dec(ElementDeclaration): - literal = "FtIssuesOnHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FtIssuesOnHostFault") - kw["aname"] = "_FtIssuesOnHostFault" - if ns0.FtIssuesOnHost_Def not in ns0.FtIssuesOnHostFault_Dec.__bases__: - bases = list(ns0.FtIssuesOnHostFault_Dec.__bases__) - bases.insert(0, ns0.FtIssuesOnHost_Def) - ns0.FtIssuesOnHostFault_Dec.__bases__ = tuple(bases) - - ns0.FtIssuesOnHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FtIssuesOnHostFault_Dec_Holder" - - class FullStorageVMotionNotSupportedFault_Dec(ElementDeclaration): - literal = "FullStorageVMotionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FullStorageVMotionNotSupportedFault") - kw["aname"] = "_FullStorageVMotionNotSupportedFault" - if ns0.FullStorageVMotionNotSupported_Def not in ns0.FullStorageVMotionNotSupportedFault_Dec.__bases__: - bases = list(ns0.FullStorageVMotionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.FullStorageVMotionNotSupported_Def) - ns0.FullStorageVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.FullStorageVMotionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FullStorageVMotionNotSupportedFault_Dec_Holder" - - class GenericDrsFaultFault_Dec(ElementDeclaration): - literal = "GenericDrsFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GenericDrsFaultFault") - kw["aname"] = "_GenericDrsFaultFault" - if ns0.GenericDrsFault_Def not in ns0.GenericDrsFaultFault_Dec.__bases__: - bases = list(ns0.GenericDrsFaultFault_Dec.__bases__) - bases.insert(0, ns0.GenericDrsFault_Def) - ns0.GenericDrsFaultFault_Dec.__bases__ = tuple(bases) - - ns0.GenericDrsFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GenericDrsFaultFault_Dec_Holder" - - class GenericVmConfigFaultFault_Dec(ElementDeclaration): - literal = "GenericVmConfigFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","GenericVmConfigFaultFault") - kw["aname"] = "_GenericVmConfigFaultFault" - if ns0.GenericVmConfigFault_Def not in ns0.GenericVmConfigFaultFault_Dec.__bases__: - bases = list(ns0.GenericVmConfigFaultFault_Dec.__bases__) - bases.insert(0, ns0.GenericVmConfigFault_Def) - ns0.GenericVmConfigFaultFault_Dec.__bases__ = tuple(bases) - - ns0.GenericVmConfigFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "GenericVmConfigFaultFault_Dec_Holder" - - class HAErrorsAtDestFault_Dec(ElementDeclaration): - literal = "HAErrorsAtDestFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HAErrorsAtDestFault") - kw["aname"] = "_HAErrorsAtDestFault" - if ns0.HAErrorsAtDest_Def not in ns0.HAErrorsAtDestFault_Dec.__bases__: - bases = list(ns0.HAErrorsAtDestFault_Dec.__bases__) - bases.insert(0, ns0.HAErrorsAtDest_Def) - ns0.HAErrorsAtDestFault_Dec.__bases__ = tuple(bases) - - ns0.HAErrorsAtDest_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HAErrorsAtDestFault_Dec_Holder" - - class HostConfigFailedFault_Dec(ElementDeclaration): - literal = "HostConfigFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostConfigFailedFault") - kw["aname"] = "_HostConfigFailedFault" - if ns0.HostConfigFailed_Def not in ns0.HostConfigFailedFault_Dec.__bases__: - bases = list(ns0.HostConfigFailedFault_Dec.__bases__) - bases.insert(0, ns0.HostConfigFailed_Def) - ns0.HostConfigFailedFault_Dec.__bases__ = tuple(bases) - - ns0.HostConfigFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostConfigFailedFault_Dec_Holder" - - class HostConfigFaultFault_Dec(ElementDeclaration): - literal = "HostConfigFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostConfigFaultFault") - kw["aname"] = "_HostConfigFaultFault" - if ns0.HostConfigFault_Def not in ns0.HostConfigFaultFault_Dec.__bases__: - bases = list(ns0.HostConfigFaultFault_Dec.__bases__) - bases.insert(0, ns0.HostConfigFault_Def) - ns0.HostConfigFaultFault_Dec.__bases__ = tuple(bases) - - ns0.HostConfigFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostConfigFaultFault_Dec_Holder" - - class HostConnectFaultFault_Dec(ElementDeclaration): - literal = "HostConnectFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostConnectFaultFault") - kw["aname"] = "_HostConnectFaultFault" - if ns0.HostConnectFault_Def not in ns0.HostConnectFaultFault_Dec.__bases__: - bases = list(ns0.HostConnectFaultFault_Dec.__bases__) - bases.insert(0, ns0.HostConnectFault_Def) - ns0.HostConnectFaultFault_Dec.__bases__ = tuple(bases) - - ns0.HostConnectFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostConnectFaultFault_Dec_Holder" - - class HostIncompatibleForFaultToleranceFault_Dec(ElementDeclaration): - literal = "HostIncompatibleForFaultToleranceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostIncompatibleForFaultToleranceFault") - kw["aname"] = "_HostIncompatibleForFaultToleranceFault" - if ns0.HostIncompatibleForFaultTolerance_Def not in ns0.HostIncompatibleForFaultToleranceFault_Dec.__bases__: - bases = list(ns0.HostIncompatibleForFaultToleranceFault_Dec.__bases__) - bases.insert(0, ns0.HostIncompatibleForFaultTolerance_Def) - ns0.HostIncompatibleForFaultToleranceFault_Dec.__bases__ = tuple(bases) - - ns0.HostIncompatibleForFaultTolerance_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostIncompatibleForFaultToleranceFault_Dec_Holder" - - class HostIncompatibleForRecordReplayFault_Dec(ElementDeclaration): - literal = "HostIncompatibleForRecordReplayFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostIncompatibleForRecordReplayFault") - kw["aname"] = "_HostIncompatibleForRecordReplayFault" - if ns0.HostIncompatibleForRecordReplay_Def not in ns0.HostIncompatibleForRecordReplayFault_Dec.__bases__: - bases = list(ns0.HostIncompatibleForRecordReplayFault_Dec.__bases__) - bases.insert(0, ns0.HostIncompatibleForRecordReplay_Def) - ns0.HostIncompatibleForRecordReplayFault_Dec.__bases__ = tuple(bases) - - ns0.HostIncompatibleForRecordReplay_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostIncompatibleForRecordReplayFault_Dec_Holder" - - class HostInventoryFullFault_Dec(ElementDeclaration): - literal = "HostInventoryFullFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostInventoryFullFault") - kw["aname"] = "_HostInventoryFullFault" - if ns0.HostInventoryFull_Def not in ns0.HostInventoryFullFault_Dec.__bases__: - bases = list(ns0.HostInventoryFullFault_Dec.__bases__) - bases.insert(0, ns0.HostInventoryFull_Def) - ns0.HostInventoryFullFault_Dec.__bases__ = tuple(bases) - - ns0.HostInventoryFull_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostInventoryFullFault_Dec_Holder" - - class HostPowerOpFailedFault_Dec(ElementDeclaration): - literal = "HostPowerOpFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostPowerOpFailedFault") - kw["aname"] = "_HostPowerOpFailedFault" - if ns0.HostPowerOpFailed_Def not in ns0.HostPowerOpFailedFault_Dec.__bases__: - bases = list(ns0.HostPowerOpFailedFault_Dec.__bases__) - bases.insert(0, ns0.HostPowerOpFailed_Def) - ns0.HostPowerOpFailedFault_Dec.__bases__ = tuple(bases) - - ns0.HostPowerOpFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostPowerOpFailedFault_Dec_Holder" - - class HotSnapshotMoveNotSupportedFault_Dec(ElementDeclaration): - literal = "HotSnapshotMoveNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HotSnapshotMoveNotSupportedFault") - kw["aname"] = "_HotSnapshotMoveNotSupportedFault" - if ns0.HotSnapshotMoveNotSupported_Def not in ns0.HotSnapshotMoveNotSupportedFault_Dec.__bases__: - bases = list(ns0.HotSnapshotMoveNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.HotSnapshotMoveNotSupported_Def) - ns0.HotSnapshotMoveNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.HotSnapshotMoveNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HotSnapshotMoveNotSupportedFault_Dec_Holder" - - class IDEDiskNotSupportedFault_Dec(ElementDeclaration): - literal = "IDEDiskNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IDEDiskNotSupportedFault") - kw["aname"] = "_IDEDiskNotSupportedFault" - if ns0.IDEDiskNotSupported_Def not in ns0.IDEDiskNotSupportedFault_Dec.__bases__: - bases = list(ns0.IDEDiskNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.IDEDiskNotSupported_Def) - ns0.IDEDiskNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.IDEDiskNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IDEDiskNotSupportedFault_Dec_Holder" - - class InUseFeatureManipulationDisallowedFault_Dec(ElementDeclaration): - literal = "InUseFeatureManipulationDisallowedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InUseFeatureManipulationDisallowedFault") - kw["aname"] = "_InUseFeatureManipulationDisallowedFault" - if ns0.InUseFeatureManipulationDisallowed_Def not in ns0.InUseFeatureManipulationDisallowedFault_Dec.__bases__: - bases = list(ns0.InUseFeatureManipulationDisallowedFault_Dec.__bases__) - bases.insert(0, ns0.InUseFeatureManipulationDisallowed_Def) - ns0.InUseFeatureManipulationDisallowedFault_Dec.__bases__ = tuple(bases) - - ns0.InUseFeatureManipulationDisallowed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InUseFeatureManipulationDisallowedFault_Dec_Holder" - - class InaccessibleDatastoreFault_Dec(ElementDeclaration): - literal = "InaccessibleDatastoreFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InaccessibleDatastoreFault") - kw["aname"] = "_InaccessibleDatastoreFault" - if ns0.InaccessibleDatastore_Def not in ns0.InaccessibleDatastoreFault_Dec.__bases__: - bases = list(ns0.InaccessibleDatastoreFault_Dec.__bases__) - bases.insert(0, ns0.InaccessibleDatastore_Def) - ns0.InaccessibleDatastoreFault_Dec.__bases__ = tuple(bases) - - ns0.InaccessibleDatastore_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InaccessibleDatastoreFault_Dec_Holder" - - class IncompatibleDefaultDeviceFault_Dec(ElementDeclaration): - literal = "IncompatibleDefaultDeviceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IncompatibleDefaultDeviceFault") - kw["aname"] = "_IncompatibleDefaultDeviceFault" - if ns0.IncompatibleDefaultDevice_Def not in ns0.IncompatibleDefaultDeviceFault_Dec.__bases__: - bases = list(ns0.IncompatibleDefaultDeviceFault_Dec.__bases__) - bases.insert(0, ns0.IncompatibleDefaultDevice_Def) - ns0.IncompatibleDefaultDeviceFault_Dec.__bases__ = tuple(bases) - - ns0.IncompatibleDefaultDevice_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IncompatibleDefaultDeviceFault_Dec_Holder" - - class IncompatibleHostForFtSecondaryFault_Dec(ElementDeclaration): - literal = "IncompatibleHostForFtSecondaryFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IncompatibleHostForFtSecondaryFault") - kw["aname"] = "_IncompatibleHostForFtSecondaryFault" - if ns0.IncompatibleHostForFtSecondary_Def not in ns0.IncompatibleHostForFtSecondaryFault_Dec.__bases__: - bases = list(ns0.IncompatibleHostForFtSecondaryFault_Dec.__bases__) - bases.insert(0, ns0.IncompatibleHostForFtSecondary_Def) - ns0.IncompatibleHostForFtSecondaryFault_Dec.__bases__ = tuple(bases) - - ns0.IncompatibleHostForFtSecondary_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IncompatibleHostForFtSecondaryFault_Dec_Holder" - - class IncompatibleSettingFault_Dec(ElementDeclaration): - literal = "IncompatibleSettingFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IncompatibleSettingFault") - kw["aname"] = "_IncompatibleSettingFault" - if ns0.IncompatibleSetting_Def not in ns0.IncompatibleSettingFault_Dec.__bases__: - bases = list(ns0.IncompatibleSettingFault_Dec.__bases__) - bases.insert(0, ns0.IncompatibleSetting_Def) - ns0.IncompatibleSettingFault_Dec.__bases__ = tuple(bases) - - ns0.IncompatibleSetting_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IncompatibleSettingFault_Dec_Holder" - - class IncorrectFileTypeFault_Dec(ElementDeclaration): - literal = "IncorrectFileTypeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IncorrectFileTypeFault") - kw["aname"] = "_IncorrectFileTypeFault" - if ns0.IncorrectFileType_Def not in ns0.IncorrectFileTypeFault_Dec.__bases__: - bases = list(ns0.IncorrectFileTypeFault_Dec.__bases__) - bases.insert(0, ns0.IncorrectFileType_Def) - ns0.IncorrectFileTypeFault_Dec.__bases__ = tuple(bases) - - ns0.IncorrectFileType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IncorrectFileTypeFault_Dec_Holder" - - class IncorrectHostInformationFault_Dec(ElementDeclaration): - literal = "IncorrectHostInformationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IncorrectHostInformationFault") - kw["aname"] = "_IncorrectHostInformationFault" - if ns0.IncorrectHostInformation_Def not in ns0.IncorrectHostInformationFault_Dec.__bases__: - bases = list(ns0.IncorrectHostInformationFault_Dec.__bases__) - bases.insert(0, ns0.IncorrectHostInformation_Def) - ns0.IncorrectHostInformationFault_Dec.__bases__ = tuple(bases) - - ns0.IncorrectHostInformation_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IncorrectHostInformationFault_Dec_Holder" - - class IndependentDiskVMotionNotSupportedFault_Dec(ElementDeclaration): - literal = "IndependentDiskVMotionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IndependentDiskVMotionNotSupportedFault") - kw["aname"] = "_IndependentDiskVMotionNotSupportedFault" - if ns0.IndependentDiskVMotionNotSupported_Def not in ns0.IndependentDiskVMotionNotSupportedFault_Dec.__bases__: - bases = list(ns0.IndependentDiskVMotionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.IndependentDiskVMotionNotSupported_Def) - ns0.IndependentDiskVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.IndependentDiskVMotionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IndependentDiskVMotionNotSupportedFault_Dec_Holder" - - class InsufficientCpuResourcesFaultFault_Dec(ElementDeclaration): - literal = "InsufficientCpuResourcesFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientCpuResourcesFaultFault") - kw["aname"] = "_InsufficientCpuResourcesFaultFault" - if ns0.InsufficientCpuResourcesFault_Def not in ns0.InsufficientCpuResourcesFaultFault_Dec.__bases__: - bases = list(ns0.InsufficientCpuResourcesFaultFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientCpuResourcesFault_Def) - ns0.InsufficientCpuResourcesFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientCpuResourcesFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientCpuResourcesFaultFault_Dec_Holder" - - class InsufficientFailoverResourcesFaultFault_Dec(ElementDeclaration): - literal = "InsufficientFailoverResourcesFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientFailoverResourcesFaultFault") - kw["aname"] = "_InsufficientFailoverResourcesFaultFault" - if ns0.InsufficientFailoverResourcesFault_Def not in ns0.InsufficientFailoverResourcesFaultFault_Dec.__bases__: - bases = list(ns0.InsufficientFailoverResourcesFaultFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientFailoverResourcesFault_Def) - ns0.InsufficientFailoverResourcesFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientFailoverResourcesFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientFailoverResourcesFaultFault_Dec_Holder" - - class InsufficientHostCapacityFaultFault_Dec(ElementDeclaration): - literal = "InsufficientHostCapacityFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientHostCapacityFaultFault") - kw["aname"] = "_InsufficientHostCapacityFaultFault" - if ns0.InsufficientHostCapacityFault_Def not in ns0.InsufficientHostCapacityFaultFault_Dec.__bases__: - bases = list(ns0.InsufficientHostCapacityFaultFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientHostCapacityFault_Def) - ns0.InsufficientHostCapacityFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientHostCapacityFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientHostCapacityFaultFault_Dec_Holder" - - class InsufficientHostCpuCapacityFaultFault_Dec(ElementDeclaration): - literal = "InsufficientHostCpuCapacityFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientHostCpuCapacityFaultFault") - kw["aname"] = "_InsufficientHostCpuCapacityFaultFault" - if ns0.InsufficientHostCpuCapacityFault_Def not in ns0.InsufficientHostCpuCapacityFaultFault_Dec.__bases__: - bases = list(ns0.InsufficientHostCpuCapacityFaultFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientHostCpuCapacityFault_Def) - ns0.InsufficientHostCpuCapacityFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientHostCpuCapacityFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientHostCpuCapacityFaultFault_Dec_Holder" - - class InsufficientHostMemoryCapacityFaultFault_Dec(ElementDeclaration): - literal = "InsufficientHostMemoryCapacityFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientHostMemoryCapacityFaultFault") - kw["aname"] = "_InsufficientHostMemoryCapacityFaultFault" - if ns0.InsufficientHostMemoryCapacityFault_Def not in ns0.InsufficientHostMemoryCapacityFaultFault_Dec.__bases__: - bases = list(ns0.InsufficientHostMemoryCapacityFaultFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientHostMemoryCapacityFault_Def) - ns0.InsufficientHostMemoryCapacityFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientHostMemoryCapacityFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientHostMemoryCapacityFaultFault_Dec_Holder" - - class InsufficientMemoryResourcesFaultFault_Dec(ElementDeclaration): - literal = "InsufficientMemoryResourcesFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientMemoryResourcesFaultFault") - kw["aname"] = "_InsufficientMemoryResourcesFaultFault" - if ns0.InsufficientMemoryResourcesFault_Def not in ns0.InsufficientMemoryResourcesFaultFault_Dec.__bases__: - bases = list(ns0.InsufficientMemoryResourcesFaultFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientMemoryResourcesFault_Def) - ns0.InsufficientMemoryResourcesFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientMemoryResourcesFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientMemoryResourcesFaultFault_Dec_Holder" - - class InsufficientPerCpuCapacityFault_Dec(ElementDeclaration): - literal = "InsufficientPerCpuCapacityFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientPerCpuCapacityFault") - kw["aname"] = "_InsufficientPerCpuCapacityFault" - if ns0.InsufficientPerCpuCapacity_Def not in ns0.InsufficientPerCpuCapacityFault_Dec.__bases__: - bases = list(ns0.InsufficientPerCpuCapacityFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientPerCpuCapacity_Def) - ns0.InsufficientPerCpuCapacityFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientPerCpuCapacity_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientPerCpuCapacityFault_Dec_Holder" - - class InsufficientResourcesFaultFault_Dec(ElementDeclaration): - literal = "InsufficientResourcesFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientResourcesFaultFault") - kw["aname"] = "_InsufficientResourcesFaultFault" - if ns0.InsufficientResourcesFault_Def not in ns0.InsufficientResourcesFaultFault_Dec.__bases__: - bases = list(ns0.InsufficientResourcesFaultFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientResourcesFault_Def) - ns0.InsufficientResourcesFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientResourcesFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientResourcesFaultFault_Dec_Holder" - - class InsufficientStandbyCpuResourceFault_Dec(ElementDeclaration): - literal = "InsufficientStandbyCpuResourceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientStandbyCpuResourceFault") - kw["aname"] = "_InsufficientStandbyCpuResourceFault" - if ns0.InsufficientStandbyCpuResource_Def not in ns0.InsufficientStandbyCpuResourceFault_Dec.__bases__: - bases = list(ns0.InsufficientStandbyCpuResourceFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientStandbyCpuResource_Def) - ns0.InsufficientStandbyCpuResourceFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientStandbyCpuResource_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientStandbyCpuResourceFault_Dec_Holder" - - class InsufficientStandbyMemoryResourceFault_Dec(ElementDeclaration): - literal = "InsufficientStandbyMemoryResourceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientStandbyMemoryResourceFault") - kw["aname"] = "_InsufficientStandbyMemoryResourceFault" - if ns0.InsufficientStandbyMemoryResource_Def not in ns0.InsufficientStandbyMemoryResourceFault_Dec.__bases__: - bases = list(ns0.InsufficientStandbyMemoryResourceFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientStandbyMemoryResource_Def) - ns0.InsufficientStandbyMemoryResourceFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientStandbyMemoryResource_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientStandbyMemoryResourceFault_Dec_Holder" - - class InsufficientStandbyResourceFault_Dec(ElementDeclaration): - literal = "InsufficientStandbyResourceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InsufficientStandbyResourceFault") - kw["aname"] = "_InsufficientStandbyResourceFault" - if ns0.InsufficientStandbyResource_Def not in ns0.InsufficientStandbyResourceFault_Dec.__bases__: - bases = list(ns0.InsufficientStandbyResourceFault_Dec.__bases__) - bases.insert(0, ns0.InsufficientStandbyResource_Def) - ns0.InsufficientStandbyResourceFault_Dec.__bases__ = tuple(bases) - - ns0.InsufficientStandbyResource_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InsufficientStandbyResourceFault_Dec_Holder" - - class InvalidAffinitySettingFaultFault_Dec(ElementDeclaration): - literal = "InvalidAffinitySettingFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidAffinitySettingFaultFault") - kw["aname"] = "_InvalidAffinitySettingFaultFault" - if ns0.InvalidAffinitySettingFault_Def not in ns0.InvalidAffinitySettingFaultFault_Dec.__bases__: - bases = list(ns0.InvalidAffinitySettingFaultFault_Dec.__bases__) - bases.insert(0, ns0.InvalidAffinitySettingFault_Def) - ns0.InvalidAffinitySettingFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidAffinitySettingFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidAffinitySettingFaultFault_Dec_Holder" - - class InvalidBmcRoleFault_Dec(ElementDeclaration): - literal = "InvalidBmcRoleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidBmcRoleFault") - kw["aname"] = "_InvalidBmcRoleFault" - if ns0.InvalidBmcRole_Def not in ns0.InvalidBmcRoleFault_Dec.__bases__: - bases = list(ns0.InvalidBmcRoleFault_Dec.__bases__) - bases.insert(0, ns0.InvalidBmcRole_Def) - ns0.InvalidBmcRoleFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidBmcRole_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidBmcRoleFault_Dec_Holder" - - class InvalidBundleFault_Dec(ElementDeclaration): - literal = "InvalidBundleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidBundleFault") - kw["aname"] = "_InvalidBundleFault" - if ns0.InvalidBundle_Def not in ns0.InvalidBundleFault_Dec.__bases__: - bases = list(ns0.InvalidBundleFault_Dec.__bases__) - bases.insert(0, ns0.InvalidBundle_Def) - ns0.InvalidBundleFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidBundle_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidBundleFault_Dec_Holder" - - class InvalidClientCertificateFault_Dec(ElementDeclaration): - literal = "InvalidClientCertificateFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidClientCertificateFault") - kw["aname"] = "_InvalidClientCertificateFault" - if ns0.InvalidClientCertificate_Def not in ns0.InvalidClientCertificateFault_Dec.__bases__: - bases = list(ns0.InvalidClientCertificateFault_Dec.__bases__) - bases.insert(0, ns0.InvalidClientCertificate_Def) - ns0.InvalidClientCertificateFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidClientCertificate_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidClientCertificateFault_Dec_Holder" - - class InvalidControllerFault_Dec(ElementDeclaration): - literal = "InvalidControllerFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidControllerFault") - kw["aname"] = "_InvalidControllerFault" - if ns0.InvalidController_Def not in ns0.InvalidControllerFault_Dec.__bases__: - bases = list(ns0.InvalidControllerFault_Dec.__bases__) - bases.insert(0, ns0.InvalidController_Def) - ns0.InvalidControllerFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidController_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidControllerFault_Dec_Holder" - - class InvalidDatastoreFault_Dec(ElementDeclaration): - literal = "InvalidDatastoreFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidDatastoreFault") - kw["aname"] = "_InvalidDatastoreFault" - if ns0.InvalidDatastore_Def not in ns0.InvalidDatastoreFault_Dec.__bases__: - bases = list(ns0.InvalidDatastoreFault_Dec.__bases__) - bases.insert(0, ns0.InvalidDatastore_Def) - ns0.InvalidDatastoreFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidDatastore_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidDatastoreFault_Dec_Holder" - - class InvalidDatastorePathFault_Dec(ElementDeclaration): - literal = "InvalidDatastorePathFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidDatastorePathFault") - kw["aname"] = "_InvalidDatastorePathFault" - if ns0.InvalidDatastorePath_Def not in ns0.InvalidDatastorePathFault_Dec.__bases__: - bases = list(ns0.InvalidDatastorePathFault_Dec.__bases__) - bases.insert(0, ns0.InvalidDatastorePath_Def) - ns0.InvalidDatastorePathFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidDatastorePath_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidDatastorePathFault_Dec_Holder" - - class InvalidDeviceBackingFault_Dec(ElementDeclaration): - literal = "InvalidDeviceBackingFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidDeviceBackingFault") - kw["aname"] = "_InvalidDeviceBackingFault" - if ns0.InvalidDeviceBacking_Def not in ns0.InvalidDeviceBackingFault_Dec.__bases__: - bases = list(ns0.InvalidDeviceBackingFault_Dec.__bases__) - bases.insert(0, ns0.InvalidDeviceBacking_Def) - ns0.InvalidDeviceBackingFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidDeviceBacking_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidDeviceBackingFault_Dec_Holder" - - class InvalidDeviceOperationFault_Dec(ElementDeclaration): - literal = "InvalidDeviceOperationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidDeviceOperationFault") - kw["aname"] = "_InvalidDeviceOperationFault" - if ns0.InvalidDeviceOperation_Def not in ns0.InvalidDeviceOperationFault_Dec.__bases__: - bases = list(ns0.InvalidDeviceOperationFault_Dec.__bases__) - bases.insert(0, ns0.InvalidDeviceOperation_Def) - ns0.InvalidDeviceOperationFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidDeviceOperation_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidDeviceOperationFault_Dec_Holder" - - class InvalidDeviceSpecFault_Dec(ElementDeclaration): - literal = "InvalidDeviceSpecFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidDeviceSpecFault") - kw["aname"] = "_InvalidDeviceSpecFault" - if ns0.InvalidDeviceSpec_Def not in ns0.InvalidDeviceSpecFault_Dec.__bases__: - bases = list(ns0.InvalidDeviceSpecFault_Dec.__bases__) - bases.insert(0, ns0.InvalidDeviceSpec_Def) - ns0.InvalidDeviceSpecFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidDeviceSpec_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidDeviceSpecFault_Dec_Holder" - - class InvalidDiskFormatFault_Dec(ElementDeclaration): - literal = "InvalidDiskFormatFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidDiskFormatFault") - kw["aname"] = "_InvalidDiskFormatFault" - if ns0.InvalidDiskFormat_Def not in ns0.InvalidDiskFormatFault_Dec.__bases__: - bases = list(ns0.InvalidDiskFormatFault_Dec.__bases__) - bases.insert(0, ns0.InvalidDiskFormat_Def) - ns0.InvalidDiskFormatFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidDiskFormat_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidDiskFormatFault_Dec_Holder" - - class InvalidDrsBehaviorForFtVmFault_Dec(ElementDeclaration): - literal = "InvalidDrsBehaviorForFtVmFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidDrsBehaviorForFtVmFault") - kw["aname"] = "_InvalidDrsBehaviorForFtVmFault" - if ns0.InvalidDrsBehaviorForFtVm_Def not in ns0.InvalidDrsBehaviorForFtVmFault_Dec.__bases__: - bases = list(ns0.InvalidDrsBehaviorForFtVmFault_Dec.__bases__) - bases.insert(0, ns0.InvalidDrsBehaviorForFtVm_Def) - ns0.InvalidDrsBehaviorForFtVmFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidDrsBehaviorForFtVm_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidDrsBehaviorForFtVmFault_Dec_Holder" - - class InvalidEditionLicenseFault_Dec(ElementDeclaration): - literal = "InvalidEditionLicenseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidEditionLicenseFault") - kw["aname"] = "_InvalidEditionLicenseFault" - if ns0.InvalidEditionLicense_Def not in ns0.InvalidEditionLicenseFault_Dec.__bases__: - bases = list(ns0.InvalidEditionLicenseFault_Dec.__bases__) - bases.insert(0, ns0.InvalidEditionLicense_Def) - ns0.InvalidEditionLicenseFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidEditionLicense_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidEditionLicenseFault_Dec_Holder" - - class InvalidEventFault_Dec(ElementDeclaration): - literal = "InvalidEventFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidEventFault") - kw["aname"] = "_InvalidEventFault" - if ns0.InvalidEvent_Def not in ns0.InvalidEventFault_Dec.__bases__: - bases = list(ns0.InvalidEventFault_Dec.__bases__) - bases.insert(0, ns0.InvalidEvent_Def) - ns0.InvalidEventFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidEvent_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidEventFault_Dec_Holder" - - class InvalidFolderFault_Dec(ElementDeclaration): - literal = "InvalidFolderFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidFolderFault") - kw["aname"] = "_InvalidFolderFault" - if ns0.InvalidFolder_Def not in ns0.InvalidFolderFault_Dec.__bases__: - bases = list(ns0.InvalidFolderFault_Dec.__bases__) - bases.insert(0, ns0.InvalidFolder_Def) - ns0.InvalidFolderFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidFolder_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidFolderFault_Dec_Holder" - - class InvalidFormatFault_Dec(ElementDeclaration): - literal = "InvalidFormatFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidFormatFault") - kw["aname"] = "_InvalidFormatFault" - if ns0.InvalidFormat_Def not in ns0.InvalidFormatFault_Dec.__bases__: - bases = list(ns0.InvalidFormatFault_Dec.__bases__) - bases.insert(0, ns0.InvalidFormat_Def) - ns0.InvalidFormatFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidFormat_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidFormatFault_Dec_Holder" - - class InvalidHostStateFault_Dec(ElementDeclaration): - literal = "InvalidHostStateFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidHostStateFault") - kw["aname"] = "_InvalidHostStateFault" - if ns0.InvalidHostState_Def not in ns0.InvalidHostStateFault_Dec.__bases__: - bases = list(ns0.InvalidHostStateFault_Dec.__bases__) - bases.insert(0, ns0.InvalidHostState_Def) - ns0.InvalidHostStateFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidHostState_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidHostStateFault_Dec_Holder" - - class InvalidIndexArgumentFault_Dec(ElementDeclaration): - literal = "InvalidIndexArgumentFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidIndexArgumentFault") - kw["aname"] = "_InvalidIndexArgumentFault" - if ns0.InvalidIndexArgument_Def not in ns0.InvalidIndexArgumentFault_Dec.__bases__: - bases = list(ns0.InvalidIndexArgumentFault_Dec.__bases__) - bases.insert(0, ns0.InvalidIndexArgument_Def) - ns0.InvalidIndexArgumentFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidIndexArgument_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidIndexArgumentFault_Dec_Holder" - - class InvalidIpmiLoginInfoFault_Dec(ElementDeclaration): - literal = "InvalidIpmiLoginInfoFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidIpmiLoginInfoFault") - kw["aname"] = "_InvalidIpmiLoginInfoFault" - if ns0.InvalidIpmiLoginInfo_Def not in ns0.InvalidIpmiLoginInfoFault_Dec.__bases__: - bases = list(ns0.InvalidIpmiLoginInfoFault_Dec.__bases__) - bases.insert(0, ns0.InvalidIpmiLoginInfo_Def) - ns0.InvalidIpmiLoginInfoFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidIpmiLoginInfo_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidIpmiLoginInfoFault_Dec_Holder" - - class InvalidIpmiMacAddressFault_Dec(ElementDeclaration): - literal = "InvalidIpmiMacAddressFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidIpmiMacAddressFault") - kw["aname"] = "_InvalidIpmiMacAddressFault" - if ns0.InvalidIpmiMacAddress_Def not in ns0.InvalidIpmiMacAddressFault_Dec.__bases__: - bases = list(ns0.InvalidIpmiMacAddressFault_Dec.__bases__) - bases.insert(0, ns0.InvalidIpmiMacAddress_Def) - ns0.InvalidIpmiMacAddressFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidIpmiMacAddress_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidIpmiMacAddressFault_Dec_Holder" - - class InvalidLicenseFault_Dec(ElementDeclaration): - literal = "InvalidLicenseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidLicenseFault") - kw["aname"] = "_InvalidLicenseFault" - if ns0.InvalidLicense_Def not in ns0.InvalidLicenseFault_Dec.__bases__: - bases = list(ns0.InvalidLicenseFault_Dec.__bases__) - bases.insert(0, ns0.InvalidLicense_Def) - ns0.InvalidLicenseFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidLicense_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidLicenseFault_Dec_Holder" - - class InvalidLocaleFault_Dec(ElementDeclaration): - literal = "InvalidLocaleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidLocaleFault") - kw["aname"] = "_InvalidLocaleFault" - if ns0.InvalidLocale_Def not in ns0.InvalidLocaleFault_Dec.__bases__: - bases = list(ns0.InvalidLocaleFault_Dec.__bases__) - bases.insert(0, ns0.InvalidLocale_Def) - ns0.InvalidLocaleFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidLocale_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidLocaleFault_Dec_Holder" - - class InvalidLoginFault_Dec(ElementDeclaration): - literal = "InvalidLoginFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidLoginFault") - kw["aname"] = "_InvalidLoginFault" - if ns0.InvalidLogin_Def not in ns0.InvalidLoginFault_Dec.__bases__: - bases = list(ns0.InvalidLoginFault_Dec.__bases__) - bases.insert(0, ns0.InvalidLogin_Def) - ns0.InvalidLoginFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidLogin_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidLoginFault_Dec_Holder" - - class InvalidNameFault_Dec(ElementDeclaration): - literal = "InvalidNameFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidNameFault") - kw["aname"] = "_InvalidNameFault" - if ns0.InvalidName_Def not in ns0.InvalidNameFault_Dec.__bases__: - bases = list(ns0.InvalidNameFault_Dec.__bases__) - bases.insert(0, ns0.InvalidName_Def) - ns0.InvalidNameFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidName_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidNameFault_Dec_Holder" - - class InvalidNasCredentialsFault_Dec(ElementDeclaration): - literal = "InvalidNasCredentialsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidNasCredentialsFault") - kw["aname"] = "_InvalidNasCredentialsFault" - if ns0.InvalidNasCredentials_Def not in ns0.InvalidNasCredentialsFault_Dec.__bases__: - bases = list(ns0.InvalidNasCredentialsFault_Dec.__bases__) - bases.insert(0, ns0.InvalidNasCredentials_Def) - ns0.InvalidNasCredentialsFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidNasCredentials_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidNasCredentialsFault_Dec_Holder" - - class InvalidNetworkInTypeFault_Dec(ElementDeclaration): - literal = "InvalidNetworkInTypeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidNetworkInTypeFault") - kw["aname"] = "_InvalidNetworkInTypeFault" - if ns0.InvalidNetworkInType_Def not in ns0.InvalidNetworkInTypeFault_Dec.__bases__: - bases = list(ns0.InvalidNetworkInTypeFault_Dec.__bases__) - bases.insert(0, ns0.InvalidNetworkInType_Def) - ns0.InvalidNetworkInTypeFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidNetworkInType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidNetworkInTypeFault_Dec_Holder" - - class InvalidNetworkResourceFault_Dec(ElementDeclaration): - literal = "InvalidNetworkResourceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidNetworkResourceFault") - kw["aname"] = "_InvalidNetworkResourceFault" - if ns0.InvalidNetworkResource_Def not in ns0.InvalidNetworkResourceFault_Dec.__bases__: - bases = list(ns0.InvalidNetworkResourceFault_Dec.__bases__) - bases.insert(0, ns0.InvalidNetworkResource_Def) - ns0.InvalidNetworkResourceFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidNetworkResource_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidNetworkResourceFault_Dec_Holder" - - class InvalidOperationOnSecondaryVmFault_Dec(ElementDeclaration): - literal = "InvalidOperationOnSecondaryVmFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidOperationOnSecondaryVmFault") - kw["aname"] = "_InvalidOperationOnSecondaryVmFault" - if ns0.InvalidOperationOnSecondaryVm_Def not in ns0.InvalidOperationOnSecondaryVmFault_Dec.__bases__: - bases = list(ns0.InvalidOperationOnSecondaryVmFault_Dec.__bases__) - bases.insert(0, ns0.InvalidOperationOnSecondaryVm_Def) - ns0.InvalidOperationOnSecondaryVmFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidOperationOnSecondaryVm_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidOperationOnSecondaryVmFault_Dec_Holder" - - class InvalidPowerStateFault_Dec(ElementDeclaration): - literal = "InvalidPowerStateFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidPowerStateFault") - kw["aname"] = "_InvalidPowerStateFault" - if ns0.InvalidPowerState_Def not in ns0.InvalidPowerStateFault_Dec.__bases__: - bases = list(ns0.InvalidPowerStateFault_Dec.__bases__) - bases.insert(0, ns0.InvalidPowerState_Def) - ns0.InvalidPowerStateFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidPowerState_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidPowerStateFault_Dec_Holder" - - class InvalidPrivilegeFault_Dec(ElementDeclaration): - literal = "InvalidPrivilegeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidPrivilegeFault") - kw["aname"] = "_InvalidPrivilegeFault" - if ns0.InvalidPrivilege_Def not in ns0.InvalidPrivilegeFault_Dec.__bases__: - bases = list(ns0.InvalidPrivilegeFault_Dec.__bases__) - bases.insert(0, ns0.InvalidPrivilege_Def) - ns0.InvalidPrivilegeFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidPrivilege_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidPrivilegeFault_Dec_Holder" - - class InvalidPropertyTypeFault_Dec(ElementDeclaration): - literal = "InvalidPropertyTypeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidPropertyTypeFault") - kw["aname"] = "_InvalidPropertyTypeFault" - if ns0.InvalidPropertyType_Def not in ns0.InvalidPropertyTypeFault_Dec.__bases__: - bases = list(ns0.InvalidPropertyTypeFault_Dec.__bases__) - bases.insert(0, ns0.InvalidPropertyType_Def) - ns0.InvalidPropertyTypeFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidPropertyType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidPropertyTypeFault_Dec_Holder" - - class InvalidPropertyValueFault_Dec(ElementDeclaration): - literal = "InvalidPropertyValueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidPropertyValueFault") - kw["aname"] = "_InvalidPropertyValueFault" - if ns0.InvalidPropertyValue_Def not in ns0.InvalidPropertyValueFault_Dec.__bases__: - bases = list(ns0.InvalidPropertyValueFault_Dec.__bases__) - bases.insert(0, ns0.InvalidPropertyValue_Def) - ns0.InvalidPropertyValueFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidPropertyValue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidPropertyValueFault_Dec_Holder" - - class InvalidResourcePoolStructureFaultFault_Dec(ElementDeclaration): - literal = "InvalidResourcePoolStructureFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidResourcePoolStructureFaultFault") - kw["aname"] = "_InvalidResourcePoolStructureFaultFault" - if ns0.InvalidResourcePoolStructureFault_Def not in ns0.InvalidResourcePoolStructureFaultFault_Dec.__bases__: - bases = list(ns0.InvalidResourcePoolStructureFaultFault_Dec.__bases__) - bases.insert(0, ns0.InvalidResourcePoolStructureFault_Def) - ns0.InvalidResourcePoolStructureFaultFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidResourcePoolStructureFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidResourcePoolStructureFaultFault_Dec_Holder" - - class InvalidSnapshotFormatFault_Dec(ElementDeclaration): - literal = "InvalidSnapshotFormatFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidSnapshotFormatFault") - kw["aname"] = "_InvalidSnapshotFormatFault" - if ns0.InvalidSnapshotFormat_Def not in ns0.InvalidSnapshotFormatFault_Dec.__bases__: - bases = list(ns0.InvalidSnapshotFormatFault_Dec.__bases__) - bases.insert(0, ns0.InvalidSnapshotFormat_Def) - ns0.InvalidSnapshotFormatFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidSnapshotFormat_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidSnapshotFormatFault_Dec_Holder" - - class InvalidStateFault_Dec(ElementDeclaration): - literal = "InvalidStateFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidStateFault") - kw["aname"] = "_InvalidStateFault" - if ns0.InvalidState_Def not in ns0.InvalidStateFault_Dec.__bases__: - bases = list(ns0.InvalidStateFault_Dec.__bases__) - bases.insert(0, ns0.InvalidState_Def) - ns0.InvalidStateFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidState_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidStateFault_Dec_Holder" - - class InvalidVmConfigFault_Dec(ElementDeclaration): - literal = "InvalidVmConfigFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InvalidVmConfigFault") - kw["aname"] = "_InvalidVmConfigFault" - if ns0.InvalidVmConfig_Def not in ns0.InvalidVmConfigFault_Dec.__bases__: - bases = list(ns0.InvalidVmConfigFault_Dec.__bases__) - bases.insert(0, ns0.InvalidVmConfig_Def) - ns0.InvalidVmConfigFault_Dec.__bases__ = tuple(bases) - - ns0.InvalidVmConfig_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InvalidVmConfigFault_Dec_Holder" - - class InventoryHasStandardAloneHostsFault_Dec(ElementDeclaration): - literal = "InventoryHasStandardAloneHostsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InventoryHasStandardAloneHostsFault") - kw["aname"] = "_InventoryHasStandardAloneHostsFault" - if ns0.InventoryHasStandardAloneHosts_Def not in ns0.InventoryHasStandardAloneHostsFault_Dec.__bases__: - bases = list(ns0.InventoryHasStandardAloneHostsFault_Dec.__bases__) - bases.insert(0, ns0.InventoryHasStandardAloneHosts_Def) - ns0.InventoryHasStandardAloneHostsFault_Dec.__bases__ = tuple(bases) - - ns0.InventoryHasStandardAloneHosts_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InventoryHasStandardAloneHostsFault_Dec_Holder" - - class IpHostnameGeneratorErrorFault_Dec(ElementDeclaration): - literal = "IpHostnameGeneratorErrorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","IpHostnameGeneratorErrorFault") - kw["aname"] = "_IpHostnameGeneratorErrorFault" - if ns0.IpHostnameGeneratorError_Def not in ns0.IpHostnameGeneratorErrorFault_Dec.__bases__: - bases = list(ns0.IpHostnameGeneratorErrorFault_Dec.__bases__) - bases.insert(0, ns0.IpHostnameGeneratorError_Def) - ns0.IpHostnameGeneratorErrorFault_Dec.__bases__ = tuple(bases) - - ns0.IpHostnameGeneratorError_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "IpHostnameGeneratorErrorFault_Dec_Holder" - - class LegacyNetworkInterfaceInUseFault_Dec(ElementDeclaration): - literal = "LegacyNetworkInterfaceInUseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LegacyNetworkInterfaceInUseFault") - kw["aname"] = "_LegacyNetworkInterfaceInUseFault" - if ns0.LegacyNetworkInterfaceInUse_Def not in ns0.LegacyNetworkInterfaceInUseFault_Dec.__bases__: - bases = list(ns0.LegacyNetworkInterfaceInUseFault_Dec.__bases__) - bases.insert(0, ns0.LegacyNetworkInterfaceInUse_Def) - ns0.LegacyNetworkInterfaceInUseFault_Dec.__bases__ = tuple(bases) - - ns0.LegacyNetworkInterfaceInUse_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LegacyNetworkInterfaceInUseFault_Dec_Holder" - - class LicenseAssignmentFailedFault_Dec(ElementDeclaration): - literal = "LicenseAssignmentFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LicenseAssignmentFailedFault") - kw["aname"] = "_LicenseAssignmentFailedFault" - if ns0.LicenseAssignmentFailed_Def not in ns0.LicenseAssignmentFailedFault_Dec.__bases__: - bases = list(ns0.LicenseAssignmentFailedFault_Dec.__bases__) - bases.insert(0, ns0.LicenseAssignmentFailed_Def) - ns0.LicenseAssignmentFailedFault_Dec.__bases__ = tuple(bases) - - ns0.LicenseAssignmentFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LicenseAssignmentFailedFault_Dec_Holder" - - class LicenseDowngradeDisallowedFault_Dec(ElementDeclaration): - literal = "LicenseDowngradeDisallowedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LicenseDowngradeDisallowedFault") - kw["aname"] = "_LicenseDowngradeDisallowedFault" - if ns0.LicenseDowngradeDisallowed_Def not in ns0.LicenseDowngradeDisallowedFault_Dec.__bases__: - bases = list(ns0.LicenseDowngradeDisallowedFault_Dec.__bases__) - bases.insert(0, ns0.LicenseDowngradeDisallowed_Def) - ns0.LicenseDowngradeDisallowedFault_Dec.__bases__ = tuple(bases) - - ns0.LicenseDowngradeDisallowed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LicenseDowngradeDisallowedFault_Dec_Holder" - - class LicenseExpiredFault_Dec(ElementDeclaration): - literal = "LicenseExpiredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LicenseExpiredFault") - kw["aname"] = "_LicenseExpiredFault" - if ns0.LicenseExpired_Def not in ns0.LicenseExpiredFault_Dec.__bases__: - bases = list(ns0.LicenseExpiredFault_Dec.__bases__) - bases.insert(0, ns0.LicenseExpired_Def) - ns0.LicenseExpiredFault_Dec.__bases__ = tuple(bases) - - ns0.LicenseExpired_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LicenseExpiredFault_Dec_Holder" - - class LicenseKeyEntityMismatchFault_Dec(ElementDeclaration): - literal = "LicenseKeyEntityMismatchFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LicenseKeyEntityMismatchFault") - kw["aname"] = "_LicenseKeyEntityMismatchFault" - if ns0.LicenseKeyEntityMismatch_Def not in ns0.LicenseKeyEntityMismatchFault_Dec.__bases__: - bases = list(ns0.LicenseKeyEntityMismatchFault_Dec.__bases__) - bases.insert(0, ns0.LicenseKeyEntityMismatch_Def) - ns0.LicenseKeyEntityMismatchFault_Dec.__bases__ = tuple(bases) - - ns0.LicenseKeyEntityMismatch_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LicenseKeyEntityMismatchFault_Dec_Holder" - - class LicenseRestrictedFault_Dec(ElementDeclaration): - literal = "LicenseRestrictedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LicenseRestrictedFault") - kw["aname"] = "_LicenseRestrictedFault" - if ns0.LicenseRestricted_Def not in ns0.LicenseRestrictedFault_Dec.__bases__: - bases = list(ns0.LicenseRestrictedFault_Dec.__bases__) - bases.insert(0, ns0.LicenseRestricted_Def) - ns0.LicenseRestrictedFault_Dec.__bases__ = tuple(bases) - - ns0.LicenseRestricted_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LicenseRestrictedFault_Dec_Holder" - - class LicenseServerUnavailableFault_Dec(ElementDeclaration): - literal = "LicenseServerUnavailableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LicenseServerUnavailableFault") - kw["aname"] = "_LicenseServerUnavailableFault" - if ns0.LicenseServerUnavailable_Def not in ns0.LicenseServerUnavailableFault_Dec.__bases__: - bases = list(ns0.LicenseServerUnavailableFault_Dec.__bases__) - bases.insert(0, ns0.LicenseServerUnavailable_Def) - ns0.LicenseServerUnavailableFault_Dec.__bases__ = tuple(bases) - - ns0.LicenseServerUnavailable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LicenseServerUnavailableFault_Dec_Holder" - - class LicenseSourceUnavailableFault_Dec(ElementDeclaration): - literal = "LicenseSourceUnavailableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LicenseSourceUnavailableFault") - kw["aname"] = "_LicenseSourceUnavailableFault" - if ns0.LicenseSourceUnavailable_Def not in ns0.LicenseSourceUnavailableFault_Dec.__bases__: - bases = list(ns0.LicenseSourceUnavailableFault_Dec.__bases__) - bases.insert(0, ns0.LicenseSourceUnavailable_Def) - ns0.LicenseSourceUnavailableFault_Dec.__bases__ = tuple(bases) - - ns0.LicenseSourceUnavailable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LicenseSourceUnavailableFault_Dec_Holder" - - class LimitExceededFault_Dec(ElementDeclaration): - literal = "LimitExceededFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LimitExceededFault") - kw["aname"] = "_LimitExceededFault" - if ns0.LimitExceeded_Def not in ns0.LimitExceededFault_Dec.__bases__: - bases = list(ns0.LimitExceededFault_Dec.__bases__) - bases.insert(0, ns0.LimitExceeded_Def) - ns0.LimitExceededFault_Dec.__bases__ = tuple(bases) - - ns0.LimitExceeded_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LimitExceededFault_Dec_Holder" - - class LinuxVolumeNotCleanFault_Dec(ElementDeclaration): - literal = "LinuxVolumeNotCleanFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LinuxVolumeNotCleanFault") - kw["aname"] = "_LinuxVolumeNotCleanFault" - if ns0.LinuxVolumeNotClean_Def not in ns0.LinuxVolumeNotCleanFault_Dec.__bases__: - bases = list(ns0.LinuxVolumeNotCleanFault_Dec.__bases__) - bases.insert(0, ns0.LinuxVolumeNotClean_Def) - ns0.LinuxVolumeNotCleanFault_Dec.__bases__ = tuple(bases) - - ns0.LinuxVolumeNotClean_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LinuxVolumeNotCleanFault_Dec_Holder" - - class LogBundlingFailedFault_Dec(ElementDeclaration): - literal = "LogBundlingFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","LogBundlingFailedFault") - kw["aname"] = "_LogBundlingFailedFault" - if ns0.LogBundlingFailed_Def not in ns0.LogBundlingFailedFault_Dec.__bases__: - bases = list(ns0.LogBundlingFailedFault_Dec.__bases__) - bases.insert(0, ns0.LogBundlingFailed_Def) - ns0.LogBundlingFailedFault_Dec.__bases__ = tuple(bases) - - ns0.LogBundlingFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "LogBundlingFailedFault_Dec_Holder" - - class MaintenanceModeFileMoveFault_Dec(ElementDeclaration): - literal = "MaintenanceModeFileMoveFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MaintenanceModeFileMoveFault") - kw["aname"] = "_MaintenanceModeFileMoveFault" - if ns0.MaintenanceModeFileMove_Def not in ns0.MaintenanceModeFileMoveFault_Dec.__bases__: - bases = list(ns0.MaintenanceModeFileMoveFault_Dec.__bases__) - bases.insert(0, ns0.MaintenanceModeFileMove_Def) - ns0.MaintenanceModeFileMoveFault_Dec.__bases__ = tuple(bases) - - ns0.MaintenanceModeFileMove_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MaintenanceModeFileMoveFault_Dec_Holder" - - class MemoryHotPlugNotSupportedFault_Dec(ElementDeclaration): - literal = "MemoryHotPlugNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MemoryHotPlugNotSupportedFault") - kw["aname"] = "_MemoryHotPlugNotSupportedFault" - if ns0.MemoryHotPlugNotSupported_Def not in ns0.MemoryHotPlugNotSupportedFault_Dec.__bases__: - bases = list(ns0.MemoryHotPlugNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.MemoryHotPlugNotSupported_Def) - ns0.MemoryHotPlugNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.MemoryHotPlugNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MemoryHotPlugNotSupportedFault_Dec_Holder" - - class MemorySizeNotRecommendedFault_Dec(ElementDeclaration): - literal = "MemorySizeNotRecommendedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MemorySizeNotRecommendedFault") - kw["aname"] = "_MemorySizeNotRecommendedFault" - if ns0.MemorySizeNotRecommended_Def not in ns0.MemorySizeNotRecommendedFault_Dec.__bases__: - bases = list(ns0.MemorySizeNotRecommendedFault_Dec.__bases__) - bases.insert(0, ns0.MemorySizeNotRecommended_Def) - ns0.MemorySizeNotRecommendedFault_Dec.__bases__ = tuple(bases) - - ns0.MemorySizeNotRecommended_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MemorySizeNotRecommendedFault_Dec_Holder" - - class MemorySizeNotSupportedFault_Dec(ElementDeclaration): - literal = "MemorySizeNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MemorySizeNotSupportedFault") - kw["aname"] = "_MemorySizeNotSupportedFault" - if ns0.MemorySizeNotSupported_Def not in ns0.MemorySizeNotSupportedFault_Dec.__bases__: - bases = list(ns0.MemorySizeNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.MemorySizeNotSupported_Def) - ns0.MemorySizeNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.MemorySizeNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MemorySizeNotSupportedFault_Dec_Holder" - - class MemorySnapshotOnIndependentDiskFault_Dec(ElementDeclaration): - literal = "MemorySnapshotOnIndependentDiskFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MemorySnapshotOnIndependentDiskFault") - kw["aname"] = "_MemorySnapshotOnIndependentDiskFault" - if ns0.MemorySnapshotOnIndependentDisk_Def not in ns0.MemorySnapshotOnIndependentDiskFault_Dec.__bases__: - bases = list(ns0.MemorySnapshotOnIndependentDiskFault_Dec.__bases__) - bases.insert(0, ns0.MemorySnapshotOnIndependentDisk_Def) - ns0.MemorySnapshotOnIndependentDiskFault_Dec.__bases__ = tuple(bases) - - ns0.MemorySnapshotOnIndependentDisk_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MemorySnapshotOnIndependentDiskFault_Dec_Holder" - - class MethodDisabledFault_Dec(ElementDeclaration): - literal = "MethodDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MethodDisabledFault") - kw["aname"] = "_MethodDisabledFault" - if ns0.MethodDisabled_Def not in ns0.MethodDisabledFault_Dec.__bases__: - bases = list(ns0.MethodDisabledFault_Dec.__bases__) - bases.insert(0, ns0.MethodDisabled_Def) - ns0.MethodDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.MethodDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MethodDisabledFault_Dec_Holder" - - class MigrationDisabledFault_Dec(ElementDeclaration): - literal = "MigrationDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MigrationDisabledFault") - kw["aname"] = "_MigrationDisabledFault" - if ns0.MigrationDisabled_Def not in ns0.MigrationDisabledFault_Dec.__bases__: - bases = list(ns0.MigrationDisabledFault_Dec.__bases__) - bases.insert(0, ns0.MigrationDisabled_Def) - ns0.MigrationDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.MigrationDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MigrationDisabledFault_Dec_Holder" - - class MigrationFaultFault_Dec(ElementDeclaration): - literal = "MigrationFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MigrationFaultFault") - kw["aname"] = "_MigrationFaultFault" - if ns0.MigrationFault_Def not in ns0.MigrationFaultFault_Dec.__bases__: - bases = list(ns0.MigrationFaultFault_Dec.__bases__) - bases.insert(0, ns0.MigrationFault_Def) - ns0.MigrationFaultFault_Dec.__bases__ = tuple(bases) - - ns0.MigrationFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MigrationFaultFault_Dec_Holder" - - class MigrationFeatureNotSupportedFault_Dec(ElementDeclaration): - literal = "MigrationFeatureNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MigrationFeatureNotSupportedFault") - kw["aname"] = "_MigrationFeatureNotSupportedFault" - if ns0.MigrationFeatureNotSupported_Def not in ns0.MigrationFeatureNotSupportedFault_Dec.__bases__: - bases = list(ns0.MigrationFeatureNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.MigrationFeatureNotSupported_Def) - ns0.MigrationFeatureNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.MigrationFeatureNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MigrationFeatureNotSupportedFault_Dec_Holder" - - class MigrationNotReadyFault_Dec(ElementDeclaration): - literal = "MigrationNotReadyFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MigrationNotReadyFault") - kw["aname"] = "_MigrationNotReadyFault" - if ns0.MigrationNotReady_Def not in ns0.MigrationNotReadyFault_Dec.__bases__: - bases = list(ns0.MigrationNotReadyFault_Dec.__bases__) - bases.insert(0, ns0.MigrationNotReady_Def) - ns0.MigrationNotReadyFault_Dec.__bases__ = tuple(bases) - - ns0.MigrationNotReady_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MigrationNotReadyFault_Dec_Holder" - - class MismatchedBundleFault_Dec(ElementDeclaration): - literal = "MismatchedBundleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MismatchedBundleFault") - kw["aname"] = "_MismatchedBundleFault" - if ns0.MismatchedBundle_Def not in ns0.MismatchedBundleFault_Dec.__bases__: - bases = list(ns0.MismatchedBundleFault_Dec.__bases__) - bases.insert(0, ns0.MismatchedBundle_Def) - ns0.MismatchedBundleFault_Dec.__bases__ = tuple(bases) - - ns0.MismatchedBundle_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MismatchedBundleFault_Dec_Holder" - - class MismatchedNetworkPoliciesFault_Dec(ElementDeclaration): - literal = "MismatchedNetworkPoliciesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MismatchedNetworkPoliciesFault") - kw["aname"] = "_MismatchedNetworkPoliciesFault" - if ns0.MismatchedNetworkPolicies_Def not in ns0.MismatchedNetworkPoliciesFault_Dec.__bases__: - bases = list(ns0.MismatchedNetworkPoliciesFault_Dec.__bases__) - bases.insert(0, ns0.MismatchedNetworkPolicies_Def) - ns0.MismatchedNetworkPoliciesFault_Dec.__bases__ = tuple(bases) - - ns0.MismatchedNetworkPolicies_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MismatchedNetworkPoliciesFault_Dec_Holder" - - class MismatchedVMotionNetworkNamesFault_Dec(ElementDeclaration): - literal = "MismatchedVMotionNetworkNamesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MismatchedVMotionNetworkNamesFault") - kw["aname"] = "_MismatchedVMotionNetworkNamesFault" - if ns0.MismatchedVMotionNetworkNames_Def not in ns0.MismatchedVMotionNetworkNamesFault_Dec.__bases__: - bases = list(ns0.MismatchedVMotionNetworkNamesFault_Dec.__bases__) - bases.insert(0, ns0.MismatchedVMotionNetworkNames_Def) - ns0.MismatchedVMotionNetworkNamesFault_Dec.__bases__ = tuple(bases) - - ns0.MismatchedVMotionNetworkNames_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MismatchedVMotionNetworkNamesFault_Dec_Holder" - - class MissingBmcSupportFault_Dec(ElementDeclaration): - literal = "MissingBmcSupportFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MissingBmcSupportFault") - kw["aname"] = "_MissingBmcSupportFault" - if ns0.MissingBmcSupport_Def not in ns0.MissingBmcSupportFault_Dec.__bases__: - bases = list(ns0.MissingBmcSupportFault_Dec.__bases__) - bases.insert(0, ns0.MissingBmcSupport_Def) - ns0.MissingBmcSupportFault_Dec.__bases__ = tuple(bases) - - ns0.MissingBmcSupport_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MissingBmcSupportFault_Dec_Holder" - - class MissingControllerFault_Dec(ElementDeclaration): - literal = "MissingControllerFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MissingControllerFault") - kw["aname"] = "_MissingControllerFault" - if ns0.MissingController_Def not in ns0.MissingControllerFault_Dec.__bases__: - bases = list(ns0.MissingControllerFault_Dec.__bases__) - bases.insert(0, ns0.MissingController_Def) - ns0.MissingControllerFault_Dec.__bases__ = tuple(bases) - - ns0.MissingController_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MissingControllerFault_Dec_Holder" - - class MissingLinuxCustResourcesFault_Dec(ElementDeclaration): - literal = "MissingLinuxCustResourcesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MissingLinuxCustResourcesFault") - kw["aname"] = "_MissingLinuxCustResourcesFault" - if ns0.MissingLinuxCustResources_Def not in ns0.MissingLinuxCustResourcesFault_Dec.__bases__: - bases = list(ns0.MissingLinuxCustResourcesFault_Dec.__bases__) - bases.insert(0, ns0.MissingLinuxCustResources_Def) - ns0.MissingLinuxCustResourcesFault_Dec.__bases__ = tuple(bases) - - ns0.MissingLinuxCustResources_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MissingLinuxCustResourcesFault_Dec_Holder" - - class MissingNetworkIpConfigFault_Dec(ElementDeclaration): - literal = "MissingNetworkIpConfigFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MissingNetworkIpConfigFault") - kw["aname"] = "_MissingNetworkIpConfigFault" - if ns0.MissingNetworkIpConfig_Def not in ns0.MissingNetworkIpConfigFault_Dec.__bases__: - bases = list(ns0.MissingNetworkIpConfigFault_Dec.__bases__) - bases.insert(0, ns0.MissingNetworkIpConfig_Def) - ns0.MissingNetworkIpConfigFault_Dec.__bases__ = tuple(bases) - - ns0.MissingNetworkIpConfig_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MissingNetworkIpConfigFault_Dec_Holder" - - class MissingPowerOffConfigurationFault_Dec(ElementDeclaration): - literal = "MissingPowerOffConfigurationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MissingPowerOffConfigurationFault") - kw["aname"] = "_MissingPowerOffConfigurationFault" - if ns0.MissingPowerOffConfiguration_Def not in ns0.MissingPowerOffConfigurationFault_Dec.__bases__: - bases = list(ns0.MissingPowerOffConfigurationFault_Dec.__bases__) - bases.insert(0, ns0.MissingPowerOffConfiguration_Def) - ns0.MissingPowerOffConfigurationFault_Dec.__bases__ = tuple(bases) - - ns0.MissingPowerOffConfiguration_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MissingPowerOffConfigurationFault_Dec_Holder" - - class MissingPowerOnConfigurationFault_Dec(ElementDeclaration): - literal = "MissingPowerOnConfigurationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MissingPowerOnConfigurationFault") - kw["aname"] = "_MissingPowerOnConfigurationFault" - if ns0.MissingPowerOnConfiguration_Def not in ns0.MissingPowerOnConfigurationFault_Dec.__bases__: - bases = list(ns0.MissingPowerOnConfigurationFault_Dec.__bases__) - bases.insert(0, ns0.MissingPowerOnConfiguration_Def) - ns0.MissingPowerOnConfigurationFault_Dec.__bases__ = tuple(bases) - - ns0.MissingPowerOnConfiguration_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MissingPowerOnConfigurationFault_Dec_Holder" - - class MissingWindowsCustResourcesFault_Dec(ElementDeclaration): - literal = "MissingWindowsCustResourcesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MissingWindowsCustResourcesFault") - kw["aname"] = "_MissingWindowsCustResourcesFault" - if ns0.MissingWindowsCustResources_Def not in ns0.MissingWindowsCustResourcesFault_Dec.__bases__: - bases = list(ns0.MissingWindowsCustResourcesFault_Dec.__bases__) - bases.insert(0, ns0.MissingWindowsCustResources_Def) - ns0.MissingWindowsCustResourcesFault_Dec.__bases__ = tuple(bases) - - ns0.MissingWindowsCustResources_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MissingWindowsCustResourcesFault_Dec_Holder" - - class MountErrorFault_Dec(ElementDeclaration): - literal = "MountErrorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MountErrorFault") - kw["aname"] = "_MountErrorFault" - if ns0.MountError_Def not in ns0.MountErrorFault_Dec.__bases__: - bases = list(ns0.MountErrorFault_Dec.__bases__) - bases.insert(0, ns0.MountError_Def) - ns0.MountErrorFault_Dec.__bases__ = tuple(bases) - - ns0.MountError_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MountErrorFault_Dec_Holder" - - class MultipleCertificatesVerifyFaultFault_Dec(ElementDeclaration): - literal = "MultipleCertificatesVerifyFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MultipleCertificatesVerifyFaultFault") - kw["aname"] = "_MultipleCertificatesVerifyFaultFault" - if ns0.MultipleCertificatesVerifyFault_Def not in ns0.MultipleCertificatesVerifyFaultFault_Dec.__bases__: - bases = list(ns0.MultipleCertificatesVerifyFaultFault_Dec.__bases__) - bases.insert(0, ns0.MultipleCertificatesVerifyFault_Def) - ns0.MultipleCertificatesVerifyFaultFault_Dec.__bases__ = tuple(bases) - - ns0.MultipleCertificatesVerifyFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MultipleCertificatesVerifyFaultFault_Dec_Holder" - - class MultipleSnapshotsNotSupportedFault_Dec(ElementDeclaration): - literal = "MultipleSnapshotsNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","MultipleSnapshotsNotSupportedFault") - kw["aname"] = "_MultipleSnapshotsNotSupportedFault" - if ns0.MultipleSnapshotsNotSupported_Def not in ns0.MultipleSnapshotsNotSupportedFault_Dec.__bases__: - bases = list(ns0.MultipleSnapshotsNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.MultipleSnapshotsNotSupported_Def) - ns0.MultipleSnapshotsNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.MultipleSnapshotsNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "MultipleSnapshotsNotSupportedFault_Dec_Holder" - - class NasConfigFaultFault_Dec(ElementDeclaration): - literal = "NasConfigFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NasConfigFaultFault") - kw["aname"] = "_NasConfigFaultFault" - if ns0.NasConfigFault_Def not in ns0.NasConfigFaultFault_Dec.__bases__: - bases = list(ns0.NasConfigFaultFault_Dec.__bases__) - bases.insert(0, ns0.NasConfigFault_Def) - ns0.NasConfigFaultFault_Dec.__bases__ = tuple(bases) - - ns0.NasConfigFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NasConfigFaultFault_Dec_Holder" - - class NasConnectionLimitReachedFault_Dec(ElementDeclaration): - literal = "NasConnectionLimitReachedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NasConnectionLimitReachedFault") - kw["aname"] = "_NasConnectionLimitReachedFault" - if ns0.NasConnectionLimitReached_Def not in ns0.NasConnectionLimitReachedFault_Dec.__bases__: - bases = list(ns0.NasConnectionLimitReachedFault_Dec.__bases__) - bases.insert(0, ns0.NasConnectionLimitReached_Def) - ns0.NasConnectionLimitReachedFault_Dec.__bases__ = tuple(bases) - - ns0.NasConnectionLimitReached_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NasConnectionLimitReachedFault_Dec_Holder" - - class NasSessionCredentialConflictFault_Dec(ElementDeclaration): - literal = "NasSessionCredentialConflictFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NasSessionCredentialConflictFault") - kw["aname"] = "_NasSessionCredentialConflictFault" - if ns0.NasSessionCredentialConflict_Def not in ns0.NasSessionCredentialConflictFault_Dec.__bases__: - bases = list(ns0.NasSessionCredentialConflictFault_Dec.__bases__) - bases.insert(0, ns0.NasSessionCredentialConflict_Def) - ns0.NasSessionCredentialConflictFault_Dec.__bases__ = tuple(bases) - - ns0.NasSessionCredentialConflict_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NasSessionCredentialConflictFault_Dec_Holder" - - class NasVolumeNotMountedFault_Dec(ElementDeclaration): - literal = "NasVolumeNotMountedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NasVolumeNotMountedFault") - kw["aname"] = "_NasVolumeNotMountedFault" - if ns0.NasVolumeNotMounted_Def not in ns0.NasVolumeNotMountedFault_Dec.__bases__: - bases = list(ns0.NasVolumeNotMountedFault_Dec.__bases__) - bases.insert(0, ns0.NasVolumeNotMounted_Def) - ns0.NasVolumeNotMountedFault_Dec.__bases__ = tuple(bases) - - ns0.NasVolumeNotMounted_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NasVolumeNotMountedFault_Dec_Holder" - - class NetworkCopyFaultFault_Dec(ElementDeclaration): - literal = "NetworkCopyFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NetworkCopyFaultFault") - kw["aname"] = "_NetworkCopyFaultFault" - if ns0.NetworkCopyFault_Def not in ns0.NetworkCopyFaultFault_Dec.__bases__: - bases = list(ns0.NetworkCopyFaultFault_Dec.__bases__) - bases.insert(0, ns0.NetworkCopyFault_Def) - ns0.NetworkCopyFaultFault_Dec.__bases__ = tuple(bases) - - ns0.NetworkCopyFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NetworkCopyFaultFault_Dec_Holder" - - class NetworkInaccessibleFault_Dec(ElementDeclaration): - literal = "NetworkInaccessibleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NetworkInaccessibleFault") - kw["aname"] = "_NetworkInaccessibleFault" - if ns0.NetworkInaccessible_Def not in ns0.NetworkInaccessibleFault_Dec.__bases__: - bases = list(ns0.NetworkInaccessibleFault_Dec.__bases__) - bases.insert(0, ns0.NetworkInaccessible_Def) - ns0.NetworkInaccessibleFault_Dec.__bases__ = tuple(bases) - - ns0.NetworkInaccessible_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NetworkInaccessibleFault_Dec_Holder" - - class NetworksMayNotBeTheSameFault_Dec(ElementDeclaration): - literal = "NetworksMayNotBeTheSameFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NetworksMayNotBeTheSameFault") - kw["aname"] = "_NetworksMayNotBeTheSameFault" - if ns0.NetworksMayNotBeTheSame_Def not in ns0.NetworksMayNotBeTheSameFault_Dec.__bases__: - bases = list(ns0.NetworksMayNotBeTheSameFault_Dec.__bases__) - bases.insert(0, ns0.NetworksMayNotBeTheSame_Def) - ns0.NetworksMayNotBeTheSameFault_Dec.__bases__ = tuple(bases) - - ns0.NetworksMayNotBeTheSame_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NetworksMayNotBeTheSameFault_Dec_Holder" - - class NicSettingMismatchFault_Dec(ElementDeclaration): - literal = "NicSettingMismatchFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NicSettingMismatchFault") - kw["aname"] = "_NicSettingMismatchFault" - if ns0.NicSettingMismatch_Def not in ns0.NicSettingMismatchFault_Dec.__bases__: - bases = list(ns0.NicSettingMismatchFault_Dec.__bases__) - bases.insert(0, ns0.NicSettingMismatch_Def) - ns0.NicSettingMismatchFault_Dec.__bases__ = tuple(bases) - - ns0.NicSettingMismatch_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NicSettingMismatchFault_Dec_Holder" - - class NoActiveHostInClusterFault_Dec(ElementDeclaration): - literal = "NoActiveHostInClusterFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoActiveHostInClusterFault") - kw["aname"] = "_NoActiveHostInClusterFault" - if ns0.NoActiveHostInCluster_Def not in ns0.NoActiveHostInClusterFault_Dec.__bases__: - bases = list(ns0.NoActiveHostInClusterFault_Dec.__bases__) - bases.insert(0, ns0.NoActiveHostInCluster_Def) - ns0.NoActiveHostInClusterFault_Dec.__bases__ = tuple(bases) - - ns0.NoActiveHostInCluster_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoActiveHostInClusterFault_Dec_Holder" - - class NoAvailableIpFault_Dec(ElementDeclaration): - literal = "NoAvailableIpFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoAvailableIpFault") - kw["aname"] = "_NoAvailableIpFault" - if ns0.NoAvailableIp_Def not in ns0.NoAvailableIpFault_Dec.__bases__: - bases = list(ns0.NoAvailableIpFault_Dec.__bases__) - bases.insert(0, ns0.NoAvailableIp_Def) - ns0.NoAvailableIpFault_Dec.__bases__ = tuple(bases) - - ns0.NoAvailableIp_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoAvailableIpFault_Dec_Holder" - - class NoClientCertificateFault_Dec(ElementDeclaration): - literal = "NoClientCertificateFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoClientCertificateFault") - kw["aname"] = "_NoClientCertificateFault" - if ns0.NoClientCertificate_Def not in ns0.NoClientCertificateFault_Dec.__bases__: - bases = list(ns0.NoClientCertificateFault_Dec.__bases__) - bases.insert(0, ns0.NoClientCertificate_Def) - ns0.NoClientCertificateFault_Dec.__bases__ = tuple(bases) - - ns0.NoClientCertificate_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoClientCertificateFault_Dec_Holder" - - class NoCompatibleHostFault_Dec(ElementDeclaration): - literal = "NoCompatibleHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoCompatibleHostFault") - kw["aname"] = "_NoCompatibleHostFault" - if ns0.NoCompatibleHost_Def not in ns0.NoCompatibleHostFault_Dec.__bases__: - bases = list(ns0.NoCompatibleHostFault_Dec.__bases__) - bases.insert(0, ns0.NoCompatibleHost_Def) - ns0.NoCompatibleHostFault_Dec.__bases__ = tuple(bases) - - ns0.NoCompatibleHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoCompatibleHostFault_Dec_Holder" - - class NoDiskFoundFault_Dec(ElementDeclaration): - literal = "NoDiskFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoDiskFoundFault") - kw["aname"] = "_NoDiskFoundFault" - if ns0.NoDiskFound_Def not in ns0.NoDiskFoundFault_Dec.__bases__: - bases = list(ns0.NoDiskFoundFault_Dec.__bases__) - bases.insert(0, ns0.NoDiskFound_Def) - ns0.NoDiskFoundFault_Dec.__bases__ = tuple(bases) - - ns0.NoDiskFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoDiskFoundFault_Dec_Holder" - - class NoDiskSpaceFault_Dec(ElementDeclaration): - literal = "NoDiskSpaceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoDiskSpaceFault") - kw["aname"] = "_NoDiskSpaceFault" - if ns0.NoDiskSpace_Def not in ns0.NoDiskSpaceFault_Dec.__bases__: - bases = list(ns0.NoDiskSpaceFault_Dec.__bases__) - bases.insert(0, ns0.NoDiskSpace_Def) - ns0.NoDiskSpaceFault_Dec.__bases__ = tuple(bases) - - ns0.NoDiskSpace_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoDiskSpaceFault_Dec_Holder" - - class NoDisksToCustomizeFault_Dec(ElementDeclaration): - literal = "NoDisksToCustomizeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoDisksToCustomizeFault") - kw["aname"] = "_NoDisksToCustomizeFault" - if ns0.NoDisksToCustomize_Def not in ns0.NoDisksToCustomizeFault_Dec.__bases__: - bases = list(ns0.NoDisksToCustomizeFault_Dec.__bases__) - bases.insert(0, ns0.NoDisksToCustomize_Def) - ns0.NoDisksToCustomizeFault_Dec.__bases__ = tuple(bases) - - ns0.NoDisksToCustomize_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoDisksToCustomizeFault_Dec_Holder" - - class NoGatewayFault_Dec(ElementDeclaration): - literal = "NoGatewayFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoGatewayFault") - kw["aname"] = "_NoGatewayFault" - if ns0.NoGateway_Def not in ns0.NoGatewayFault_Dec.__bases__: - bases = list(ns0.NoGatewayFault_Dec.__bases__) - bases.insert(0, ns0.NoGateway_Def) - ns0.NoGatewayFault_Dec.__bases__ = tuple(bases) - - ns0.NoGateway_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoGatewayFault_Dec_Holder" - - class NoGuestHeartbeatFault_Dec(ElementDeclaration): - literal = "NoGuestHeartbeatFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoGuestHeartbeatFault") - kw["aname"] = "_NoGuestHeartbeatFault" - if ns0.NoGuestHeartbeat_Def not in ns0.NoGuestHeartbeatFault_Dec.__bases__: - bases = list(ns0.NoGuestHeartbeatFault_Dec.__bases__) - bases.insert(0, ns0.NoGuestHeartbeat_Def) - ns0.NoGuestHeartbeatFault_Dec.__bases__ = tuple(bases) - - ns0.NoGuestHeartbeat_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoGuestHeartbeatFault_Dec_Holder" - - class NoHostFault_Dec(ElementDeclaration): - literal = "NoHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoHostFault") - kw["aname"] = "_NoHostFault" - if ns0.NoHost_Def not in ns0.NoHostFault_Dec.__bases__: - bases = list(ns0.NoHostFault_Dec.__bases__) - bases.insert(0, ns0.NoHost_Def) - ns0.NoHostFault_Dec.__bases__ = tuple(bases) - - ns0.NoHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoHostFault_Dec_Holder" - - class NoHostSuitableForFtSecondaryFault_Dec(ElementDeclaration): - literal = "NoHostSuitableForFtSecondaryFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoHostSuitableForFtSecondaryFault") - kw["aname"] = "_NoHostSuitableForFtSecondaryFault" - if ns0.NoHostSuitableForFtSecondary_Def not in ns0.NoHostSuitableForFtSecondaryFault_Dec.__bases__: - bases = list(ns0.NoHostSuitableForFtSecondaryFault_Dec.__bases__) - bases.insert(0, ns0.NoHostSuitableForFtSecondary_Def) - ns0.NoHostSuitableForFtSecondaryFault_Dec.__bases__ = tuple(bases) - - ns0.NoHostSuitableForFtSecondary_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoHostSuitableForFtSecondaryFault_Dec_Holder" - - class NoLicenseServerConfiguredFault_Dec(ElementDeclaration): - literal = "NoLicenseServerConfiguredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoLicenseServerConfiguredFault") - kw["aname"] = "_NoLicenseServerConfiguredFault" - if ns0.NoLicenseServerConfigured_Def not in ns0.NoLicenseServerConfiguredFault_Dec.__bases__: - bases = list(ns0.NoLicenseServerConfiguredFault_Dec.__bases__) - bases.insert(0, ns0.NoLicenseServerConfigured_Def) - ns0.NoLicenseServerConfiguredFault_Dec.__bases__ = tuple(bases) - - ns0.NoLicenseServerConfigured_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoLicenseServerConfiguredFault_Dec_Holder" - - class NoPeerHostFoundFault_Dec(ElementDeclaration): - literal = "NoPeerHostFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoPeerHostFoundFault") - kw["aname"] = "_NoPeerHostFoundFault" - if ns0.NoPeerHostFound_Def not in ns0.NoPeerHostFoundFault_Dec.__bases__: - bases = list(ns0.NoPeerHostFoundFault_Dec.__bases__) - bases.insert(0, ns0.NoPeerHostFound_Def) - ns0.NoPeerHostFoundFault_Dec.__bases__ = tuple(bases) - - ns0.NoPeerHostFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoPeerHostFoundFault_Dec_Holder" - - class NoPermissionFault_Dec(ElementDeclaration): - literal = "NoPermissionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoPermissionFault") - kw["aname"] = "_NoPermissionFault" - if ns0.NoPermission_Def not in ns0.NoPermissionFault_Dec.__bases__: - bases = list(ns0.NoPermissionFault_Dec.__bases__) - bases.insert(0, ns0.NoPermission_Def) - ns0.NoPermissionFault_Dec.__bases__ = tuple(bases) - - ns0.NoPermission_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoPermissionFault_Dec_Holder" - - class NoPermissionOnHostFault_Dec(ElementDeclaration): - literal = "NoPermissionOnHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoPermissionOnHostFault") - kw["aname"] = "_NoPermissionOnHostFault" - if ns0.NoPermissionOnHost_Def not in ns0.NoPermissionOnHostFault_Dec.__bases__: - bases = list(ns0.NoPermissionOnHostFault_Dec.__bases__) - bases.insert(0, ns0.NoPermissionOnHost_Def) - ns0.NoPermissionOnHostFault_Dec.__bases__ = tuple(bases) - - ns0.NoPermissionOnHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoPermissionOnHostFault_Dec_Holder" - - class NoPermissionOnNasVolumeFault_Dec(ElementDeclaration): - literal = "NoPermissionOnNasVolumeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoPermissionOnNasVolumeFault") - kw["aname"] = "_NoPermissionOnNasVolumeFault" - if ns0.NoPermissionOnNasVolume_Def not in ns0.NoPermissionOnNasVolumeFault_Dec.__bases__: - bases = list(ns0.NoPermissionOnNasVolumeFault_Dec.__bases__) - bases.insert(0, ns0.NoPermissionOnNasVolume_Def) - ns0.NoPermissionOnNasVolumeFault_Dec.__bases__ = tuple(bases) - - ns0.NoPermissionOnNasVolume_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoPermissionOnNasVolumeFault_Dec_Holder" - - class NoSubjectNameFault_Dec(ElementDeclaration): - literal = "NoSubjectNameFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoSubjectNameFault") - kw["aname"] = "_NoSubjectNameFault" - if ns0.NoSubjectName_Def not in ns0.NoSubjectNameFault_Dec.__bases__: - bases = list(ns0.NoSubjectNameFault_Dec.__bases__) - bases.insert(0, ns0.NoSubjectName_Def) - ns0.NoSubjectNameFault_Dec.__bases__ = tuple(bases) - - ns0.NoSubjectName_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoSubjectNameFault_Dec_Holder" - - class NoVcManagedIpConfiguredFault_Dec(ElementDeclaration): - literal = "NoVcManagedIpConfiguredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoVcManagedIpConfiguredFault") - kw["aname"] = "_NoVcManagedIpConfiguredFault" - if ns0.NoVcManagedIpConfigured_Def not in ns0.NoVcManagedIpConfiguredFault_Dec.__bases__: - bases = list(ns0.NoVcManagedIpConfiguredFault_Dec.__bases__) - bases.insert(0, ns0.NoVcManagedIpConfigured_Def) - ns0.NoVcManagedIpConfiguredFault_Dec.__bases__ = tuple(bases) - - ns0.NoVcManagedIpConfigured_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoVcManagedIpConfiguredFault_Dec_Holder" - - class NoVirtualNicFault_Dec(ElementDeclaration): - literal = "NoVirtualNicFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoVirtualNicFault") - kw["aname"] = "_NoVirtualNicFault" - if ns0.NoVirtualNic_Def not in ns0.NoVirtualNicFault_Dec.__bases__: - bases = list(ns0.NoVirtualNicFault_Dec.__bases__) - bases.insert(0, ns0.NoVirtualNic_Def) - ns0.NoVirtualNicFault_Dec.__bases__ = tuple(bases) - - ns0.NoVirtualNic_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoVirtualNicFault_Dec_Holder" - - class NoVmInVAppFault_Dec(ElementDeclaration): - literal = "NoVmInVAppFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NoVmInVAppFault") - kw["aname"] = "_NoVmInVAppFault" - if ns0.NoVmInVApp_Def not in ns0.NoVmInVAppFault_Dec.__bases__: - bases = list(ns0.NoVmInVAppFault_Dec.__bases__) - bases.insert(0, ns0.NoVmInVApp_Def) - ns0.NoVmInVAppFault_Dec.__bases__ = tuple(bases) - - ns0.NoVmInVApp_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NoVmInVAppFault_Dec_Holder" - - class NonHomeRDMVMotionNotSupportedFault_Dec(ElementDeclaration): - literal = "NonHomeRDMVMotionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NonHomeRDMVMotionNotSupportedFault") - kw["aname"] = "_NonHomeRDMVMotionNotSupportedFault" - if ns0.NonHomeRDMVMotionNotSupported_Def not in ns0.NonHomeRDMVMotionNotSupportedFault_Dec.__bases__: - bases = list(ns0.NonHomeRDMVMotionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.NonHomeRDMVMotionNotSupported_Def) - ns0.NonHomeRDMVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.NonHomeRDMVMotionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NonHomeRDMVMotionNotSupportedFault_Dec_Holder" - - class NonPersistentDisksNotSupportedFault_Dec(ElementDeclaration): - literal = "NonPersistentDisksNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NonPersistentDisksNotSupportedFault") - kw["aname"] = "_NonPersistentDisksNotSupportedFault" - if ns0.NonPersistentDisksNotSupported_Def not in ns0.NonPersistentDisksNotSupportedFault_Dec.__bases__: - bases = list(ns0.NonPersistentDisksNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.NonPersistentDisksNotSupported_Def) - ns0.NonPersistentDisksNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.NonPersistentDisksNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NonPersistentDisksNotSupportedFault_Dec_Holder" - - class NotAuthenticatedFault_Dec(ElementDeclaration): - literal = "NotAuthenticatedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotAuthenticatedFault") - kw["aname"] = "_NotAuthenticatedFault" - if ns0.NotAuthenticated_Def not in ns0.NotAuthenticatedFault_Dec.__bases__: - bases = list(ns0.NotAuthenticatedFault_Dec.__bases__) - bases.insert(0, ns0.NotAuthenticated_Def) - ns0.NotAuthenticatedFault_Dec.__bases__ = tuple(bases) - - ns0.NotAuthenticated_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotAuthenticatedFault_Dec_Holder" - - class NotEnoughCpusFault_Dec(ElementDeclaration): - literal = "NotEnoughCpusFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotEnoughCpusFault") - kw["aname"] = "_NotEnoughCpusFault" - if ns0.NotEnoughCpus_Def not in ns0.NotEnoughCpusFault_Dec.__bases__: - bases = list(ns0.NotEnoughCpusFault_Dec.__bases__) - bases.insert(0, ns0.NotEnoughCpus_Def) - ns0.NotEnoughCpusFault_Dec.__bases__ = tuple(bases) - - ns0.NotEnoughCpus_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotEnoughCpusFault_Dec_Holder" - - class NotEnoughLogicalCpusFault_Dec(ElementDeclaration): - literal = "NotEnoughLogicalCpusFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotEnoughLogicalCpusFault") - kw["aname"] = "_NotEnoughLogicalCpusFault" - if ns0.NotEnoughLogicalCpus_Def not in ns0.NotEnoughLogicalCpusFault_Dec.__bases__: - bases = list(ns0.NotEnoughLogicalCpusFault_Dec.__bases__) - bases.insert(0, ns0.NotEnoughLogicalCpus_Def) - ns0.NotEnoughLogicalCpusFault_Dec.__bases__ = tuple(bases) - - ns0.NotEnoughLogicalCpus_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotEnoughLogicalCpusFault_Dec_Holder" - - class NotFoundFault_Dec(ElementDeclaration): - literal = "NotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotFoundFault") - kw["aname"] = "_NotFoundFault" - if ns0.NotFound_Def not in ns0.NotFoundFault_Dec.__bases__: - bases = list(ns0.NotFoundFault_Dec.__bases__) - bases.insert(0, ns0.NotFound_Def) - ns0.NotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.NotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotFoundFault_Dec_Holder" - - class NotSupportedHostFault_Dec(ElementDeclaration): - literal = "NotSupportedHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotSupportedHostFault") - kw["aname"] = "_NotSupportedHostFault" - if ns0.NotSupportedHost_Def not in ns0.NotSupportedHostFault_Dec.__bases__: - bases = list(ns0.NotSupportedHostFault_Dec.__bases__) - bases.insert(0, ns0.NotSupportedHost_Def) - ns0.NotSupportedHostFault_Dec.__bases__ = tuple(bases) - - ns0.NotSupportedHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotSupportedHostFault_Dec_Holder" - - class NotSupportedHostInClusterFault_Dec(ElementDeclaration): - literal = "NotSupportedHostInClusterFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotSupportedHostInClusterFault") - kw["aname"] = "_NotSupportedHostInClusterFault" - if ns0.NotSupportedHostInCluster_Def not in ns0.NotSupportedHostInClusterFault_Dec.__bases__: - bases = list(ns0.NotSupportedHostInClusterFault_Dec.__bases__) - bases.insert(0, ns0.NotSupportedHostInCluster_Def) - ns0.NotSupportedHostInClusterFault_Dec.__bases__ = tuple(bases) - - ns0.NotSupportedHostInCluster_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotSupportedHostInClusterFault_Dec_Holder" - - class NotUserConfigurablePropertyFault_Dec(ElementDeclaration): - literal = "NotUserConfigurablePropertyFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NotUserConfigurablePropertyFault") - kw["aname"] = "_NotUserConfigurablePropertyFault" - if ns0.NotUserConfigurableProperty_Def not in ns0.NotUserConfigurablePropertyFault_Dec.__bases__: - bases = list(ns0.NotUserConfigurablePropertyFault_Dec.__bases__) - bases.insert(0, ns0.NotUserConfigurableProperty_Def) - ns0.NotUserConfigurablePropertyFault_Dec.__bases__ = tuple(bases) - - ns0.NotUserConfigurableProperty_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NotUserConfigurablePropertyFault_Dec_Holder" - - class NumVirtualCpusIncompatibleFault_Dec(ElementDeclaration): - literal = "NumVirtualCpusIncompatibleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NumVirtualCpusIncompatibleFault") - kw["aname"] = "_NumVirtualCpusIncompatibleFault" - if ns0.NumVirtualCpusIncompatible_Def not in ns0.NumVirtualCpusIncompatibleFault_Dec.__bases__: - bases = list(ns0.NumVirtualCpusIncompatibleFault_Dec.__bases__) - bases.insert(0, ns0.NumVirtualCpusIncompatible_Def) - ns0.NumVirtualCpusIncompatibleFault_Dec.__bases__ = tuple(bases) - - ns0.NumVirtualCpusIncompatible_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NumVirtualCpusIncompatibleFault_Dec_Holder" - - class NumVirtualCpusNotSupportedFault_Dec(ElementDeclaration): - literal = "NumVirtualCpusNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","NumVirtualCpusNotSupportedFault") - kw["aname"] = "_NumVirtualCpusNotSupportedFault" - if ns0.NumVirtualCpusNotSupported_Def not in ns0.NumVirtualCpusNotSupportedFault_Dec.__bases__: - bases = list(ns0.NumVirtualCpusNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.NumVirtualCpusNotSupported_Def) - ns0.NumVirtualCpusNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.NumVirtualCpusNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "NumVirtualCpusNotSupportedFault_Dec_Holder" - - class OutOfBoundsFault_Dec(ElementDeclaration): - literal = "OutOfBoundsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OutOfBoundsFault") - kw["aname"] = "_OutOfBoundsFault" - if ns0.OutOfBounds_Def not in ns0.OutOfBoundsFault_Dec.__bases__: - bases = list(ns0.OutOfBoundsFault_Dec.__bases__) - bases.insert(0, ns0.OutOfBounds_Def) - ns0.OutOfBoundsFault_Dec.__bases__ = tuple(bases) - - ns0.OutOfBounds_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OutOfBoundsFault_Dec_Holder" - - class OvfAttributeFault_Dec(ElementDeclaration): - literal = "OvfAttributeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfAttributeFault") - kw["aname"] = "_OvfAttributeFault" - if ns0.OvfAttribute_Def not in ns0.OvfAttributeFault_Dec.__bases__: - bases = list(ns0.OvfAttributeFault_Dec.__bases__) - bases.insert(0, ns0.OvfAttribute_Def) - ns0.OvfAttributeFault_Dec.__bases__ = tuple(bases) - - ns0.OvfAttribute_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfAttributeFault_Dec_Holder" - - class OvfConnectedDeviceFault_Dec(ElementDeclaration): - literal = "OvfConnectedDeviceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfConnectedDeviceFault") - kw["aname"] = "_OvfConnectedDeviceFault" - if ns0.OvfConnectedDevice_Def not in ns0.OvfConnectedDeviceFault_Dec.__bases__: - bases = list(ns0.OvfConnectedDeviceFault_Dec.__bases__) - bases.insert(0, ns0.OvfConnectedDevice_Def) - ns0.OvfConnectedDeviceFault_Dec.__bases__ = tuple(bases) - - ns0.OvfConnectedDevice_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfConnectedDeviceFault_Dec_Holder" - - class OvfConnectedDeviceFloppyFault_Dec(ElementDeclaration): - literal = "OvfConnectedDeviceFloppyFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfConnectedDeviceFloppyFault") - kw["aname"] = "_OvfConnectedDeviceFloppyFault" - if ns0.OvfConnectedDeviceFloppy_Def not in ns0.OvfConnectedDeviceFloppyFault_Dec.__bases__: - bases = list(ns0.OvfConnectedDeviceFloppyFault_Dec.__bases__) - bases.insert(0, ns0.OvfConnectedDeviceFloppy_Def) - ns0.OvfConnectedDeviceFloppyFault_Dec.__bases__ = tuple(bases) - - ns0.OvfConnectedDeviceFloppy_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfConnectedDeviceFloppyFault_Dec_Holder" - - class OvfConnectedDeviceIsoFault_Dec(ElementDeclaration): - literal = "OvfConnectedDeviceIsoFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfConnectedDeviceIsoFault") - kw["aname"] = "_OvfConnectedDeviceIsoFault" - if ns0.OvfConnectedDeviceIso_Def not in ns0.OvfConnectedDeviceIsoFault_Dec.__bases__: - bases = list(ns0.OvfConnectedDeviceIsoFault_Dec.__bases__) - bases.insert(0, ns0.OvfConnectedDeviceIso_Def) - ns0.OvfConnectedDeviceIsoFault_Dec.__bases__ = tuple(bases) - - ns0.OvfConnectedDeviceIso_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfConnectedDeviceIsoFault_Dec_Holder" - - class OvfDiskMappingNotFoundFault_Dec(ElementDeclaration): - literal = "OvfDiskMappingNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfDiskMappingNotFoundFault") - kw["aname"] = "_OvfDiskMappingNotFoundFault" - if ns0.OvfDiskMappingNotFound_Def not in ns0.OvfDiskMappingNotFoundFault_Dec.__bases__: - bases = list(ns0.OvfDiskMappingNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.OvfDiskMappingNotFound_Def) - ns0.OvfDiskMappingNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.OvfDiskMappingNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfDiskMappingNotFoundFault_Dec_Holder" - - class OvfDuplicateElementFault_Dec(ElementDeclaration): - literal = "OvfDuplicateElementFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfDuplicateElementFault") - kw["aname"] = "_OvfDuplicateElementFault" - if ns0.OvfDuplicateElement_Def not in ns0.OvfDuplicateElementFault_Dec.__bases__: - bases = list(ns0.OvfDuplicateElementFault_Dec.__bases__) - bases.insert(0, ns0.OvfDuplicateElement_Def) - ns0.OvfDuplicateElementFault_Dec.__bases__ = tuple(bases) - - ns0.OvfDuplicateElement_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfDuplicateElementFault_Dec_Holder" - - class OvfDuplicatedElementBoundaryFault_Dec(ElementDeclaration): - literal = "OvfDuplicatedElementBoundaryFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfDuplicatedElementBoundaryFault") - kw["aname"] = "_OvfDuplicatedElementBoundaryFault" - if ns0.OvfDuplicatedElementBoundary_Def not in ns0.OvfDuplicatedElementBoundaryFault_Dec.__bases__: - bases = list(ns0.OvfDuplicatedElementBoundaryFault_Dec.__bases__) - bases.insert(0, ns0.OvfDuplicatedElementBoundary_Def) - ns0.OvfDuplicatedElementBoundaryFault_Dec.__bases__ = tuple(bases) - - ns0.OvfDuplicatedElementBoundary_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfDuplicatedElementBoundaryFault_Dec_Holder" - - class OvfElementFault_Dec(ElementDeclaration): - literal = "OvfElementFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfElementFault") - kw["aname"] = "_OvfElementFault" - if ns0.OvfElement_Def not in ns0.OvfElementFault_Dec.__bases__: - bases = list(ns0.OvfElementFault_Dec.__bases__) - bases.insert(0, ns0.OvfElement_Def) - ns0.OvfElementFault_Dec.__bases__ = tuple(bases) - - ns0.OvfElement_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfElementFault_Dec_Holder" - - class OvfElementInvalidValueFault_Dec(ElementDeclaration): - literal = "OvfElementInvalidValueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfElementInvalidValueFault") - kw["aname"] = "_OvfElementInvalidValueFault" - if ns0.OvfElementInvalidValue_Def not in ns0.OvfElementInvalidValueFault_Dec.__bases__: - bases = list(ns0.OvfElementInvalidValueFault_Dec.__bases__) - bases.insert(0, ns0.OvfElementInvalidValue_Def) - ns0.OvfElementInvalidValueFault_Dec.__bases__ = tuple(bases) - - ns0.OvfElementInvalidValue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfElementInvalidValueFault_Dec_Holder" - - class OvfExportFault_Dec(ElementDeclaration): - literal = "OvfExportFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfExportFault") - kw["aname"] = "_OvfExportFault" - if ns0.OvfExport_Def not in ns0.OvfExportFault_Dec.__bases__: - bases = list(ns0.OvfExportFault_Dec.__bases__) - bases.insert(0, ns0.OvfExport_Def) - ns0.OvfExportFault_Dec.__bases__ = tuple(bases) - - ns0.OvfExport_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfExportFault_Dec_Holder" - - class OvfFaultFault_Dec(ElementDeclaration): - literal = "OvfFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfFaultFault") - kw["aname"] = "_OvfFaultFault" - if ns0.OvfFault_Def not in ns0.OvfFaultFault_Dec.__bases__: - bases = list(ns0.OvfFaultFault_Dec.__bases__) - bases.insert(0, ns0.OvfFault_Def) - ns0.OvfFaultFault_Dec.__bases__ = tuple(bases) - - ns0.OvfFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfFaultFault_Dec_Holder" - - class OvfHardwareCheckFault_Dec(ElementDeclaration): - literal = "OvfHardwareCheckFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfHardwareCheckFault") - kw["aname"] = "_OvfHardwareCheckFault" - if ns0.OvfHardwareCheck_Def not in ns0.OvfHardwareCheckFault_Dec.__bases__: - bases = list(ns0.OvfHardwareCheckFault_Dec.__bases__) - bases.insert(0, ns0.OvfHardwareCheck_Def) - ns0.OvfHardwareCheckFault_Dec.__bases__ = tuple(bases) - - ns0.OvfHardwareCheck_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfHardwareCheckFault_Dec_Holder" - - class OvfHardwareExportFault_Dec(ElementDeclaration): - literal = "OvfHardwareExportFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfHardwareExportFault") - kw["aname"] = "_OvfHardwareExportFault" - if ns0.OvfHardwareExport_Def not in ns0.OvfHardwareExportFault_Dec.__bases__: - bases = list(ns0.OvfHardwareExportFault_Dec.__bases__) - bases.insert(0, ns0.OvfHardwareExport_Def) - ns0.OvfHardwareExportFault_Dec.__bases__ = tuple(bases) - - ns0.OvfHardwareExport_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfHardwareExportFault_Dec_Holder" - - class OvfHostValueNotParsedFault_Dec(ElementDeclaration): - literal = "OvfHostValueNotParsedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfHostValueNotParsedFault") - kw["aname"] = "_OvfHostValueNotParsedFault" - if ns0.OvfHostValueNotParsed_Def not in ns0.OvfHostValueNotParsedFault_Dec.__bases__: - bases = list(ns0.OvfHostValueNotParsedFault_Dec.__bases__) - bases.insert(0, ns0.OvfHostValueNotParsed_Def) - ns0.OvfHostValueNotParsedFault_Dec.__bases__ = tuple(bases) - - ns0.OvfHostValueNotParsed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfHostValueNotParsedFault_Dec_Holder" - - class OvfImportFault_Dec(ElementDeclaration): - literal = "OvfImportFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfImportFault") - kw["aname"] = "_OvfImportFault" - if ns0.OvfImport_Def not in ns0.OvfImportFault_Dec.__bases__: - bases = list(ns0.OvfImportFault_Dec.__bases__) - bases.insert(0, ns0.OvfImport_Def) - ns0.OvfImportFault_Dec.__bases__ = tuple(bases) - - ns0.OvfImport_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfImportFault_Dec_Holder" - - class OvfInvalidPackageFault_Dec(ElementDeclaration): - literal = "OvfInvalidPackageFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfInvalidPackageFault") - kw["aname"] = "_OvfInvalidPackageFault" - if ns0.OvfInvalidPackage_Def not in ns0.OvfInvalidPackageFault_Dec.__bases__: - bases = list(ns0.OvfInvalidPackageFault_Dec.__bases__) - bases.insert(0, ns0.OvfInvalidPackage_Def) - ns0.OvfInvalidPackageFault_Dec.__bases__ = tuple(bases) - - ns0.OvfInvalidPackage_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidPackageFault_Dec_Holder" - - class OvfInvalidValueFault_Dec(ElementDeclaration): - literal = "OvfInvalidValueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfInvalidValueFault") - kw["aname"] = "_OvfInvalidValueFault" - if ns0.OvfInvalidValue_Def not in ns0.OvfInvalidValueFault_Dec.__bases__: - bases = list(ns0.OvfInvalidValueFault_Dec.__bases__) - bases.insert(0, ns0.OvfInvalidValue_Def) - ns0.OvfInvalidValueFault_Dec.__bases__ = tuple(bases) - - ns0.OvfInvalidValue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueFault_Dec_Holder" - - class OvfInvalidValueConfigurationFault_Dec(ElementDeclaration): - literal = "OvfInvalidValueConfigurationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfInvalidValueConfigurationFault") - kw["aname"] = "_OvfInvalidValueConfigurationFault" - if ns0.OvfInvalidValueConfiguration_Def not in ns0.OvfInvalidValueConfigurationFault_Dec.__bases__: - bases = list(ns0.OvfInvalidValueConfigurationFault_Dec.__bases__) - bases.insert(0, ns0.OvfInvalidValueConfiguration_Def) - ns0.OvfInvalidValueConfigurationFault_Dec.__bases__ = tuple(bases) - - ns0.OvfInvalidValueConfiguration_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueConfigurationFault_Dec_Holder" - - class OvfInvalidValueEmptyFault_Dec(ElementDeclaration): - literal = "OvfInvalidValueEmptyFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfInvalidValueEmptyFault") - kw["aname"] = "_OvfInvalidValueEmptyFault" - if ns0.OvfInvalidValueEmpty_Def not in ns0.OvfInvalidValueEmptyFault_Dec.__bases__: - bases = list(ns0.OvfInvalidValueEmptyFault_Dec.__bases__) - bases.insert(0, ns0.OvfInvalidValueEmpty_Def) - ns0.OvfInvalidValueEmptyFault_Dec.__bases__ = tuple(bases) - - ns0.OvfInvalidValueEmpty_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueEmptyFault_Dec_Holder" - - class OvfInvalidValueFormatMalformedFault_Dec(ElementDeclaration): - literal = "OvfInvalidValueFormatMalformedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfInvalidValueFormatMalformedFault") - kw["aname"] = "_OvfInvalidValueFormatMalformedFault" - if ns0.OvfInvalidValueFormatMalformed_Def not in ns0.OvfInvalidValueFormatMalformedFault_Dec.__bases__: - bases = list(ns0.OvfInvalidValueFormatMalformedFault_Dec.__bases__) - bases.insert(0, ns0.OvfInvalidValueFormatMalformed_Def) - ns0.OvfInvalidValueFormatMalformedFault_Dec.__bases__ = tuple(bases) - - ns0.OvfInvalidValueFormatMalformed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueFormatMalformedFault_Dec_Holder" - - class OvfInvalidValueReferenceFault_Dec(ElementDeclaration): - literal = "OvfInvalidValueReferenceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfInvalidValueReferenceFault") - kw["aname"] = "_OvfInvalidValueReferenceFault" - if ns0.OvfInvalidValueReference_Def not in ns0.OvfInvalidValueReferenceFault_Dec.__bases__: - bases = list(ns0.OvfInvalidValueReferenceFault_Dec.__bases__) - bases.insert(0, ns0.OvfInvalidValueReference_Def) - ns0.OvfInvalidValueReferenceFault_Dec.__bases__ = tuple(bases) - - ns0.OvfInvalidValueReference_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidValueReferenceFault_Dec_Holder" - - class OvfInvalidVmNameFault_Dec(ElementDeclaration): - literal = "OvfInvalidVmNameFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfInvalidVmNameFault") - kw["aname"] = "_OvfInvalidVmNameFault" - if ns0.OvfInvalidVmName_Def not in ns0.OvfInvalidVmNameFault_Dec.__bases__: - bases = list(ns0.OvfInvalidVmNameFault_Dec.__bases__) - bases.insert(0, ns0.OvfInvalidVmName_Def) - ns0.OvfInvalidVmNameFault_Dec.__bases__ = tuple(bases) - - ns0.OvfInvalidVmName_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfInvalidVmNameFault_Dec_Holder" - - class OvfMappedOsIdFault_Dec(ElementDeclaration): - literal = "OvfMappedOsIdFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfMappedOsIdFault") - kw["aname"] = "_OvfMappedOsIdFault" - if ns0.OvfMappedOsId_Def not in ns0.OvfMappedOsIdFault_Dec.__bases__: - bases = list(ns0.OvfMappedOsIdFault_Dec.__bases__) - bases.insert(0, ns0.OvfMappedOsId_Def) - ns0.OvfMappedOsIdFault_Dec.__bases__ = tuple(bases) - - ns0.OvfMappedOsId_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfMappedOsIdFault_Dec_Holder" - - class OvfMissingAttributeFault_Dec(ElementDeclaration): - literal = "OvfMissingAttributeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfMissingAttributeFault") - kw["aname"] = "_OvfMissingAttributeFault" - if ns0.OvfMissingAttribute_Def not in ns0.OvfMissingAttributeFault_Dec.__bases__: - bases = list(ns0.OvfMissingAttributeFault_Dec.__bases__) - bases.insert(0, ns0.OvfMissingAttribute_Def) - ns0.OvfMissingAttributeFault_Dec.__bases__ = tuple(bases) - - ns0.OvfMissingAttribute_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingAttributeFault_Dec_Holder" - - class OvfMissingElementFault_Dec(ElementDeclaration): - literal = "OvfMissingElementFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfMissingElementFault") - kw["aname"] = "_OvfMissingElementFault" - if ns0.OvfMissingElement_Def not in ns0.OvfMissingElementFault_Dec.__bases__: - bases = list(ns0.OvfMissingElementFault_Dec.__bases__) - bases.insert(0, ns0.OvfMissingElement_Def) - ns0.OvfMissingElementFault_Dec.__bases__ = tuple(bases) - - ns0.OvfMissingElement_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingElementFault_Dec_Holder" - - class OvfMissingElementNormalBoundaryFault_Dec(ElementDeclaration): - literal = "OvfMissingElementNormalBoundaryFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfMissingElementNormalBoundaryFault") - kw["aname"] = "_OvfMissingElementNormalBoundaryFault" - if ns0.OvfMissingElementNormalBoundary_Def not in ns0.OvfMissingElementNormalBoundaryFault_Dec.__bases__: - bases = list(ns0.OvfMissingElementNormalBoundaryFault_Dec.__bases__) - bases.insert(0, ns0.OvfMissingElementNormalBoundary_Def) - ns0.OvfMissingElementNormalBoundaryFault_Dec.__bases__ = tuple(bases) - - ns0.OvfMissingElementNormalBoundary_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingElementNormalBoundaryFault_Dec_Holder" - - class OvfMissingHardwareFault_Dec(ElementDeclaration): - literal = "OvfMissingHardwareFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfMissingHardwareFault") - kw["aname"] = "_OvfMissingHardwareFault" - if ns0.OvfMissingHardware_Def not in ns0.OvfMissingHardwareFault_Dec.__bases__: - bases = list(ns0.OvfMissingHardwareFault_Dec.__bases__) - bases.insert(0, ns0.OvfMissingHardware_Def) - ns0.OvfMissingHardwareFault_Dec.__bases__ = tuple(bases) - - ns0.OvfMissingHardware_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfMissingHardwareFault_Dec_Holder" - - class OvfNoHostNicFault_Dec(ElementDeclaration): - literal = "OvfNoHostNicFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfNoHostNicFault") - kw["aname"] = "_OvfNoHostNicFault" - if ns0.OvfNoHostNic_Def not in ns0.OvfNoHostNicFault_Dec.__bases__: - bases = list(ns0.OvfNoHostNicFault_Dec.__bases__) - bases.insert(0, ns0.OvfNoHostNic_Def) - ns0.OvfNoHostNicFault_Dec.__bases__ = tuple(bases) - - ns0.OvfNoHostNic_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfNoHostNicFault_Dec_Holder" - - class OvfNoSupportedHardwareFamilyFault_Dec(ElementDeclaration): - literal = "OvfNoSupportedHardwareFamilyFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfNoSupportedHardwareFamilyFault") - kw["aname"] = "_OvfNoSupportedHardwareFamilyFault" - if ns0.OvfNoSupportedHardwareFamily_Def not in ns0.OvfNoSupportedHardwareFamilyFault_Dec.__bases__: - bases = list(ns0.OvfNoSupportedHardwareFamilyFault_Dec.__bases__) - bases.insert(0, ns0.OvfNoSupportedHardwareFamily_Def) - ns0.OvfNoSupportedHardwareFamilyFault_Dec.__bases__ = tuple(bases) - - ns0.OvfNoSupportedHardwareFamily_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfNoSupportedHardwareFamilyFault_Dec_Holder" - - class OvfPropertyFault_Dec(ElementDeclaration): - literal = "OvfPropertyFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyFault") - kw["aname"] = "_OvfPropertyFault" - if ns0.OvfProperty_Def not in ns0.OvfPropertyFault_Dec.__bases__: - bases = list(ns0.OvfPropertyFault_Dec.__bases__) - bases.insert(0, ns0.OvfProperty_Def) - ns0.OvfPropertyFault_Dec.__bases__ = tuple(bases) - - ns0.OvfProperty_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyFault_Dec_Holder" - - class OvfPropertyExportFault_Dec(ElementDeclaration): - literal = "OvfPropertyExportFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyExportFault") - kw["aname"] = "_OvfPropertyExportFault" - if ns0.OvfPropertyExport_Def not in ns0.OvfPropertyExportFault_Dec.__bases__: - bases = list(ns0.OvfPropertyExportFault_Dec.__bases__) - bases.insert(0, ns0.OvfPropertyExport_Def) - ns0.OvfPropertyExportFault_Dec.__bases__ = tuple(bases) - - ns0.OvfPropertyExport_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyExportFault_Dec_Holder" - - class OvfPropertyNetworkFault_Dec(ElementDeclaration): - literal = "OvfPropertyNetworkFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyNetworkFault") - kw["aname"] = "_OvfPropertyNetworkFault" - if ns0.OvfPropertyNetwork_Def not in ns0.OvfPropertyNetworkFault_Dec.__bases__: - bases = list(ns0.OvfPropertyNetworkFault_Dec.__bases__) - bases.insert(0, ns0.OvfPropertyNetwork_Def) - ns0.OvfPropertyNetworkFault_Dec.__bases__ = tuple(bases) - - ns0.OvfPropertyNetwork_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyNetworkFault_Dec_Holder" - - class OvfPropertyQualifierFault_Dec(ElementDeclaration): - literal = "OvfPropertyQualifierFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyQualifierFault") - kw["aname"] = "_OvfPropertyQualifierFault" - if ns0.OvfPropertyQualifier_Def not in ns0.OvfPropertyQualifierFault_Dec.__bases__: - bases = list(ns0.OvfPropertyQualifierFault_Dec.__bases__) - bases.insert(0, ns0.OvfPropertyQualifier_Def) - ns0.OvfPropertyQualifierFault_Dec.__bases__ = tuple(bases) - - ns0.OvfPropertyQualifier_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyQualifierFault_Dec_Holder" - - class OvfPropertyQualifierDuplicateFault_Dec(ElementDeclaration): - literal = "OvfPropertyQualifierDuplicateFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyQualifierDuplicateFault") - kw["aname"] = "_OvfPropertyQualifierDuplicateFault" - if ns0.OvfPropertyQualifierDuplicate_Def not in ns0.OvfPropertyQualifierDuplicateFault_Dec.__bases__: - bases = list(ns0.OvfPropertyQualifierDuplicateFault_Dec.__bases__) - bases.insert(0, ns0.OvfPropertyQualifierDuplicate_Def) - ns0.OvfPropertyQualifierDuplicateFault_Dec.__bases__ = tuple(bases) - - ns0.OvfPropertyQualifierDuplicate_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyQualifierDuplicateFault_Dec_Holder" - - class OvfPropertyQualifierIgnoredFault_Dec(ElementDeclaration): - literal = "OvfPropertyQualifierIgnoredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyQualifierIgnoredFault") - kw["aname"] = "_OvfPropertyQualifierIgnoredFault" - if ns0.OvfPropertyQualifierIgnored_Def not in ns0.OvfPropertyQualifierIgnoredFault_Dec.__bases__: - bases = list(ns0.OvfPropertyQualifierIgnoredFault_Dec.__bases__) - bases.insert(0, ns0.OvfPropertyQualifierIgnored_Def) - ns0.OvfPropertyQualifierIgnoredFault_Dec.__bases__ = tuple(bases) - - ns0.OvfPropertyQualifierIgnored_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyQualifierIgnoredFault_Dec_Holder" - - class OvfPropertyTypeFault_Dec(ElementDeclaration): - literal = "OvfPropertyTypeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyTypeFault") - kw["aname"] = "_OvfPropertyTypeFault" - if ns0.OvfPropertyType_Def not in ns0.OvfPropertyTypeFault_Dec.__bases__: - bases = list(ns0.OvfPropertyTypeFault_Dec.__bases__) - bases.insert(0, ns0.OvfPropertyType_Def) - ns0.OvfPropertyTypeFault_Dec.__bases__ = tuple(bases) - - ns0.OvfPropertyType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyTypeFault_Dec_Holder" - - class OvfPropertyValueFault_Dec(ElementDeclaration): - literal = "OvfPropertyValueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfPropertyValueFault") - kw["aname"] = "_OvfPropertyValueFault" - if ns0.OvfPropertyValue_Def not in ns0.OvfPropertyValueFault_Dec.__bases__: - bases = list(ns0.OvfPropertyValueFault_Dec.__bases__) - bases.insert(0, ns0.OvfPropertyValue_Def) - ns0.OvfPropertyValueFault_Dec.__bases__ = tuple(bases) - - ns0.OvfPropertyValue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfPropertyValueFault_Dec_Holder" - - class OvfSystemFaultFault_Dec(ElementDeclaration): - literal = "OvfSystemFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfSystemFaultFault") - kw["aname"] = "_OvfSystemFaultFault" - if ns0.OvfSystemFault_Def not in ns0.OvfSystemFaultFault_Dec.__bases__: - bases = list(ns0.OvfSystemFaultFault_Dec.__bases__) - bases.insert(0, ns0.OvfSystemFault_Def) - ns0.OvfSystemFaultFault_Dec.__bases__ = tuple(bases) - - ns0.OvfSystemFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfSystemFaultFault_Dec_Holder" - - class OvfToXmlUnsupportedElementFault_Dec(ElementDeclaration): - literal = "OvfToXmlUnsupportedElementFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfToXmlUnsupportedElementFault") - kw["aname"] = "_OvfToXmlUnsupportedElementFault" - if ns0.OvfToXmlUnsupportedElement_Def not in ns0.OvfToXmlUnsupportedElementFault_Dec.__bases__: - bases = list(ns0.OvfToXmlUnsupportedElementFault_Dec.__bases__) - bases.insert(0, ns0.OvfToXmlUnsupportedElement_Def) - ns0.OvfToXmlUnsupportedElementFault_Dec.__bases__ = tuple(bases) - - ns0.OvfToXmlUnsupportedElement_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfToXmlUnsupportedElementFault_Dec_Holder" - - class OvfUnableToExportDiskFault_Dec(ElementDeclaration): - literal = "OvfUnableToExportDiskFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnableToExportDiskFault") - kw["aname"] = "_OvfUnableToExportDiskFault" - if ns0.OvfUnableToExportDisk_Def not in ns0.OvfUnableToExportDiskFault_Dec.__bases__: - bases = list(ns0.OvfUnableToExportDiskFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnableToExportDisk_Def) - ns0.OvfUnableToExportDiskFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnableToExportDisk_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnableToExportDiskFault_Dec_Holder" - - class OvfUnexpectedElementFault_Dec(ElementDeclaration): - literal = "OvfUnexpectedElementFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnexpectedElementFault") - kw["aname"] = "_OvfUnexpectedElementFault" - if ns0.OvfUnexpectedElement_Def not in ns0.OvfUnexpectedElementFault_Dec.__bases__: - bases = list(ns0.OvfUnexpectedElementFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnexpectedElement_Def) - ns0.OvfUnexpectedElementFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnexpectedElement_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnexpectedElementFault_Dec_Holder" - - class OvfUnknownDeviceFault_Dec(ElementDeclaration): - literal = "OvfUnknownDeviceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnknownDeviceFault") - kw["aname"] = "_OvfUnknownDeviceFault" - if ns0.OvfUnknownDevice_Def not in ns0.OvfUnknownDeviceFault_Dec.__bases__: - bases = list(ns0.OvfUnknownDeviceFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnknownDevice_Def) - ns0.OvfUnknownDeviceFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnknownDevice_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnknownDeviceFault_Dec_Holder" - - class OvfUnknownDeviceBackingFault_Dec(ElementDeclaration): - literal = "OvfUnknownDeviceBackingFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnknownDeviceBackingFault") - kw["aname"] = "_OvfUnknownDeviceBackingFault" - if ns0.OvfUnknownDeviceBacking_Def not in ns0.OvfUnknownDeviceBackingFault_Dec.__bases__: - bases = list(ns0.OvfUnknownDeviceBackingFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnknownDeviceBacking_Def) - ns0.OvfUnknownDeviceBackingFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnknownDeviceBacking_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnknownDeviceBackingFault_Dec_Holder" - - class OvfUnknownEntityFault_Dec(ElementDeclaration): - literal = "OvfUnknownEntityFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnknownEntityFault") - kw["aname"] = "_OvfUnknownEntityFault" - if ns0.OvfUnknownEntity_Def not in ns0.OvfUnknownEntityFault_Dec.__bases__: - bases = list(ns0.OvfUnknownEntityFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnknownEntity_Def) - ns0.OvfUnknownEntityFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnknownEntity_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnknownEntityFault_Dec_Holder" - - class OvfUnsupportedAttributeFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedAttributeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedAttributeFault") - kw["aname"] = "_OvfUnsupportedAttributeFault" - if ns0.OvfUnsupportedAttribute_Def not in ns0.OvfUnsupportedAttributeFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedAttributeFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedAttribute_Def) - ns0.OvfUnsupportedAttributeFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedAttribute_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedAttributeFault_Dec_Holder" - - class OvfUnsupportedAttributeValueFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedAttributeValueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedAttributeValueFault") - kw["aname"] = "_OvfUnsupportedAttributeValueFault" - if ns0.OvfUnsupportedAttributeValue_Def not in ns0.OvfUnsupportedAttributeValueFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedAttributeValueFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedAttributeValue_Def) - ns0.OvfUnsupportedAttributeValueFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedAttributeValue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedAttributeValueFault_Dec_Holder" - - class OvfUnsupportedDeviceBackingInfoFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedDeviceBackingInfoFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedDeviceBackingInfoFault") - kw["aname"] = "_OvfUnsupportedDeviceBackingInfoFault" - if ns0.OvfUnsupportedDeviceBackingInfo_Def not in ns0.OvfUnsupportedDeviceBackingInfoFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedDeviceBackingInfoFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedDeviceBackingInfo_Def) - ns0.OvfUnsupportedDeviceBackingInfoFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedDeviceBackingInfo_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedDeviceBackingInfoFault_Dec_Holder" - - class OvfUnsupportedDeviceBackingOptionFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedDeviceBackingOptionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedDeviceBackingOptionFault") - kw["aname"] = "_OvfUnsupportedDeviceBackingOptionFault" - if ns0.OvfUnsupportedDeviceBackingOption_Def not in ns0.OvfUnsupportedDeviceBackingOptionFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedDeviceBackingOptionFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedDeviceBackingOption_Def) - ns0.OvfUnsupportedDeviceBackingOptionFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedDeviceBackingOption_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedDeviceBackingOptionFault_Dec_Holder" - - class OvfUnsupportedDeviceExportFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedDeviceExportFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedDeviceExportFault") - kw["aname"] = "_OvfUnsupportedDeviceExportFault" - if ns0.OvfUnsupportedDeviceExport_Def not in ns0.OvfUnsupportedDeviceExportFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedDeviceExportFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedDeviceExport_Def) - ns0.OvfUnsupportedDeviceExportFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedDeviceExport_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedDeviceExportFault_Dec_Holder" - - class OvfUnsupportedElementFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedElementFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedElementFault") - kw["aname"] = "_OvfUnsupportedElementFault" - if ns0.OvfUnsupportedElement_Def not in ns0.OvfUnsupportedElementFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedElementFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedElement_Def) - ns0.OvfUnsupportedElementFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedElement_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedElementFault_Dec_Holder" - - class OvfUnsupportedElementValueFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedElementValueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedElementValueFault") - kw["aname"] = "_OvfUnsupportedElementValueFault" - if ns0.OvfUnsupportedElementValue_Def not in ns0.OvfUnsupportedElementValueFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedElementValueFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedElementValue_Def) - ns0.OvfUnsupportedElementValueFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedElementValue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedElementValueFault_Dec_Holder" - - class OvfUnsupportedPackageFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedPackageFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedPackageFault") - kw["aname"] = "_OvfUnsupportedPackageFault" - if ns0.OvfUnsupportedPackage_Def not in ns0.OvfUnsupportedPackageFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedPackageFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedPackage_Def) - ns0.OvfUnsupportedPackageFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedPackage_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedPackageFault_Dec_Holder" - - class OvfUnsupportedSectionFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedSectionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedSectionFault") - kw["aname"] = "_OvfUnsupportedSectionFault" - if ns0.OvfUnsupportedSection_Def not in ns0.OvfUnsupportedSectionFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedSectionFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedSection_Def) - ns0.OvfUnsupportedSectionFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedSection_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedSectionFault_Dec_Holder" - - class OvfUnsupportedSubTypeFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedSubTypeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedSubTypeFault") - kw["aname"] = "_OvfUnsupportedSubTypeFault" - if ns0.OvfUnsupportedSubType_Def not in ns0.OvfUnsupportedSubTypeFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedSubTypeFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedSubType_Def) - ns0.OvfUnsupportedSubTypeFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedSubType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedSubTypeFault_Dec_Holder" - - class OvfUnsupportedTypeFault_Dec(ElementDeclaration): - literal = "OvfUnsupportedTypeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfUnsupportedTypeFault") - kw["aname"] = "_OvfUnsupportedTypeFault" - if ns0.OvfUnsupportedType_Def not in ns0.OvfUnsupportedTypeFault_Dec.__bases__: - bases = list(ns0.OvfUnsupportedTypeFault_Dec.__bases__) - bases.insert(0, ns0.OvfUnsupportedType_Def) - ns0.OvfUnsupportedTypeFault_Dec.__bases__ = tuple(bases) - - ns0.OvfUnsupportedType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfUnsupportedTypeFault_Dec_Holder" - - class OvfWrongElementFault_Dec(ElementDeclaration): - literal = "OvfWrongElementFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfWrongElementFault") - kw["aname"] = "_OvfWrongElementFault" - if ns0.OvfWrongElement_Def not in ns0.OvfWrongElementFault_Dec.__bases__: - bases = list(ns0.OvfWrongElementFault_Dec.__bases__) - bases.insert(0, ns0.OvfWrongElement_Def) - ns0.OvfWrongElementFault_Dec.__bases__ = tuple(bases) - - ns0.OvfWrongElement_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfWrongElementFault_Dec_Holder" - - class OvfWrongNamespaceFault_Dec(ElementDeclaration): - literal = "OvfWrongNamespaceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfWrongNamespaceFault") - kw["aname"] = "_OvfWrongNamespaceFault" - if ns0.OvfWrongNamespace_Def not in ns0.OvfWrongNamespaceFault_Dec.__bases__: - bases = list(ns0.OvfWrongNamespaceFault_Dec.__bases__) - bases.insert(0, ns0.OvfWrongNamespace_Def) - ns0.OvfWrongNamespaceFault_Dec.__bases__ = tuple(bases) - - ns0.OvfWrongNamespace_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfWrongNamespaceFault_Dec_Holder" - - class OvfXmlFormatFault_Dec(ElementDeclaration): - literal = "OvfXmlFormatFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OvfXmlFormatFault") - kw["aname"] = "_OvfXmlFormatFault" - if ns0.OvfXmlFormat_Def not in ns0.OvfXmlFormatFault_Dec.__bases__: - bases = list(ns0.OvfXmlFormatFault_Dec.__bases__) - bases.insert(0, ns0.OvfXmlFormat_Def) - ns0.OvfXmlFormatFault_Dec.__bases__ = tuple(bases) - - ns0.OvfXmlFormat_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OvfXmlFormatFault_Dec_Holder" - - class PatchAlreadyInstalledFault_Dec(ElementDeclaration): - literal = "PatchAlreadyInstalledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchAlreadyInstalledFault") - kw["aname"] = "_PatchAlreadyInstalledFault" - if ns0.PatchAlreadyInstalled_Def not in ns0.PatchAlreadyInstalledFault_Dec.__bases__: - bases = list(ns0.PatchAlreadyInstalledFault_Dec.__bases__) - bases.insert(0, ns0.PatchAlreadyInstalled_Def) - ns0.PatchAlreadyInstalledFault_Dec.__bases__ = tuple(bases) - - ns0.PatchAlreadyInstalled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchAlreadyInstalledFault_Dec_Holder" - - class PatchBinariesNotFoundFault_Dec(ElementDeclaration): - literal = "PatchBinariesNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchBinariesNotFoundFault") - kw["aname"] = "_PatchBinariesNotFoundFault" - if ns0.PatchBinariesNotFound_Def not in ns0.PatchBinariesNotFoundFault_Dec.__bases__: - bases = list(ns0.PatchBinariesNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.PatchBinariesNotFound_Def) - ns0.PatchBinariesNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.PatchBinariesNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchBinariesNotFoundFault_Dec_Holder" - - class PatchInstallFailedFault_Dec(ElementDeclaration): - literal = "PatchInstallFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchInstallFailedFault") - kw["aname"] = "_PatchInstallFailedFault" - if ns0.PatchInstallFailed_Def not in ns0.PatchInstallFailedFault_Dec.__bases__: - bases = list(ns0.PatchInstallFailedFault_Dec.__bases__) - bases.insert(0, ns0.PatchInstallFailed_Def) - ns0.PatchInstallFailedFault_Dec.__bases__ = tuple(bases) - - ns0.PatchInstallFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchInstallFailedFault_Dec_Holder" - - class PatchIntegrityErrorFault_Dec(ElementDeclaration): - literal = "PatchIntegrityErrorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchIntegrityErrorFault") - kw["aname"] = "_PatchIntegrityErrorFault" - if ns0.PatchIntegrityError_Def not in ns0.PatchIntegrityErrorFault_Dec.__bases__: - bases = list(ns0.PatchIntegrityErrorFault_Dec.__bases__) - bases.insert(0, ns0.PatchIntegrityError_Def) - ns0.PatchIntegrityErrorFault_Dec.__bases__ = tuple(bases) - - ns0.PatchIntegrityError_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchIntegrityErrorFault_Dec_Holder" - - class PatchMetadataCorruptedFault_Dec(ElementDeclaration): - literal = "PatchMetadataCorruptedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchMetadataCorruptedFault") - kw["aname"] = "_PatchMetadataCorruptedFault" - if ns0.PatchMetadataCorrupted_Def not in ns0.PatchMetadataCorruptedFault_Dec.__bases__: - bases = list(ns0.PatchMetadataCorruptedFault_Dec.__bases__) - bases.insert(0, ns0.PatchMetadataCorrupted_Def) - ns0.PatchMetadataCorruptedFault_Dec.__bases__ = tuple(bases) - - ns0.PatchMetadataCorrupted_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchMetadataCorruptedFault_Dec_Holder" - - class PatchMetadataInvalidFault_Dec(ElementDeclaration): - literal = "PatchMetadataInvalidFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchMetadataInvalidFault") - kw["aname"] = "_PatchMetadataInvalidFault" - if ns0.PatchMetadataInvalid_Def not in ns0.PatchMetadataInvalidFault_Dec.__bases__: - bases = list(ns0.PatchMetadataInvalidFault_Dec.__bases__) - bases.insert(0, ns0.PatchMetadataInvalid_Def) - ns0.PatchMetadataInvalidFault_Dec.__bases__ = tuple(bases) - - ns0.PatchMetadataInvalid_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchMetadataInvalidFault_Dec_Holder" - - class PatchMetadataNotFoundFault_Dec(ElementDeclaration): - literal = "PatchMetadataNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchMetadataNotFoundFault") - kw["aname"] = "_PatchMetadataNotFoundFault" - if ns0.PatchMetadataNotFound_Def not in ns0.PatchMetadataNotFoundFault_Dec.__bases__: - bases = list(ns0.PatchMetadataNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.PatchMetadataNotFound_Def) - ns0.PatchMetadataNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.PatchMetadataNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchMetadataNotFoundFault_Dec_Holder" - - class PatchMissingDependenciesFault_Dec(ElementDeclaration): - literal = "PatchMissingDependenciesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchMissingDependenciesFault") - kw["aname"] = "_PatchMissingDependenciesFault" - if ns0.PatchMissingDependencies_Def not in ns0.PatchMissingDependenciesFault_Dec.__bases__: - bases = list(ns0.PatchMissingDependenciesFault_Dec.__bases__) - bases.insert(0, ns0.PatchMissingDependencies_Def) - ns0.PatchMissingDependenciesFault_Dec.__bases__ = tuple(bases) - - ns0.PatchMissingDependencies_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchMissingDependenciesFault_Dec_Holder" - - class PatchNotApplicableFault_Dec(ElementDeclaration): - literal = "PatchNotApplicableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchNotApplicableFault") - kw["aname"] = "_PatchNotApplicableFault" - if ns0.PatchNotApplicable_Def not in ns0.PatchNotApplicableFault_Dec.__bases__: - bases = list(ns0.PatchNotApplicableFault_Dec.__bases__) - bases.insert(0, ns0.PatchNotApplicable_Def) - ns0.PatchNotApplicableFault_Dec.__bases__ = tuple(bases) - - ns0.PatchNotApplicable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchNotApplicableFault_Dec_Holder" - - class PatchSupersededFault_Dec(ElementDeclaration): - literal = "PatchSupersededFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PatchSupersededFault") - kw["aname"] = "_PatchSupersededFault" - if ns0.PatchSuperseded_Def not in ns0.PatchSupersededFault_Dec.__bases__: - bases = list(ns0.PatchSupersededFault_Dec.__bases__) - bases.insert(0, ns0.PatchSuperseded_Def) - ns0.PatchSupersededFault_Dec.__bases__ = tuple(bases) - - ns0.PatchSuperseded_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PatchSupersededFault_Dec_Holder" - - class PhysCompatRDMNotSupportedFault_Dec(ElementDeclaration): - literal = "PhysCompatRDMNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PhysCompatRDMNotSupportedFault") - kw["aname"] = "_PhysCompatRDMNotSupportedFault" - if ns0.PhysCompatRDMNotSupported_Def not in ns0.PhysCompatRDMNotSupportedFault_Dec.__bases__: - bases = list(ns0.PhysCompatRDMNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.PhysCompatRDMNotSupported_Def) - ns0.PhysCompatRDMNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.PhysCompatRDMNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PhysCompatRDMNotSupportedFault_Dec_Holder" - - class PlatformConfigFaultFault_Dec(ElementDeclaration): - literal = "PlatformConfigFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PlatformConfigFaultFault") - kw["aname"] = "_PlatformConfigFaultFault" - if ns0.PlatformConfigFault_Def not in ns0.PlatformConfigFaultFault_Dec.__bases__: - bases = list(ns0.PlatformConfigFaultFault_Dec.__bases__) - bases.insert(0, ns0.PlatformConfigFault_Def) - ns0.PlatformConfigFaultFault_Dec.__bases__ = tuple(bases) - - ns0.PlatformConfigFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PlatformConfigFaultFault_Dec_Holder" - - class PowerOnFtSecondaryFailedFault_Dec(ElementDeclaration): - literal = "PowerOnFtSecondaryFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnFtSecondaryFailedFault") - kw["aname"] = "_PowerOnFtSecondaryFailedFault" - if ns0.PowerOnFtSecondaryFailed_Def not in ns0.PowerOnFtSecondaryFailedFault_Dec.__bases__: - bases = list(ns0.PowerOnFtSecondaryFailedFault_Dec.__bases__) - bases.insert(0, ns0.PowerOnFtSecondaryFailed_Def) - ns0.PowerOnFtSecondaryFailedFault_Dec.__bases__ = tuple(bases) - - ns0.PowerOnFtSecondaryFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnFtSecondaryFailedFault_Dec_Holder" - - class PowerOnFtSecondaryTimedoutFault_Dec(ElementDeclaration): - literal = "PowerOnFtSecondaryTimedoutFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","PowerOnFtSecondaryTimedoutFault") - kw["aname"] = "_PowerOnFtSecondaryTimedoutFault" - if ns0.PowerOnFtSecondaryTimedout_Def not in ns0.PowerOnFtSecondaryTimedoutFault_Dec.__bases__: - bases = list(ns0.PowerOnFtSecondaryTimedoutFault_Dec.__bases__) - bases.insert(0, ns0.PowerOnFtSecondaryTimedout_Def) - ns0.PowerOnFtSecondaryTimedoutFault_Dec.__bases__ = tuple(bases) - - ns0.PowerOnFtSecondaryTimedout_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "PowerOnFtSecondaryTimedoutFault_Dec_Holder" - - class ProfileUpdateFailedFault_Dec(ElementDeclaration): - literal = "ProfileUpdateFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileUpdateFailedFault") - kw["aname"] = "_ProfileUpdateFailedFault" - if ns0.ProfileUpdateFailed_Def not in ns0.ProfileUpdateFailedFault_Dec.__bases__: - bases = list(ns0.ProfileUpdateFailedFault_Dec.__bases__) - bases.insert(0, ns0.ProfileUpdateFailed_Def) - ns0.ProfileUpdateFailedFault_Dec.__bases__ = tuple(bases) - - ns0.ProfileUpdateFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileUpdateFailedFault_Dec_Holder" - - class RDMConversionNotSupportedFault_Dec(ElementDeclaration): - literal = "RDMConversionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RDMConversionNotSupportedFault") - kw["aname"] = "_RDMConversionNotSupportedFault" - if ns0.RDMConversionNotSupported_Def not in ns0.RDMConversionNotSupportedFault_Dec.__bases__: - bases = list(ns0.RDMConversionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.RDMConversionNotSupported_Def) - ns0.RDMConversionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.RDMConversionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RDMConversionNotSupportedFault_Dec_Holder" - - class RDMNotPreservedFault_Dec(ElementDeclaration): - literal = "RDMNotPreservedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RDMNotPreservedFault") - kw["aname"] = "_RDMNotPreservedFault" - if ns0.RDMNotPreserved_Def not in ns0.RDMNotPreservedFault_Dec.__bases__: - bases = list(ns0.RDMNotPreservedFault_Dec.__bases__) - bases.insert(0, ns0.RDMNotPreserved_Def) - ns0.RDMNotPreservedFault_Dec.__bases__ = tuple(bases) - - ns0.RDMNotPreserved_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RDMNotPreservedFault_Dec_Holder" - - class RDMNotSupportedFault_Dec(ElementDeclaration): - literal = "RDMNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RDMNotSupportedFault") - kw["aname"] = "_RDMNotSupportedFault" - if ns0.RDMNotSupported_Def not in ns0.RDMNotSupportedFault_Dec.__bases__: - bases = list(ns0.RDMNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.RDMNotSupported_Def) - ns0.RDMNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.RDMNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RDMNotSupportedFault_Dec_Holder" - - class RDMNotSupportedOnDatastoreFault_Dec(ElementDeclaration): - literal = "RDMNotSupportedOnDatastoreFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RDMNotSupportedOnDatastoreFault") - kw["aname"] = "_RDMNotSupportedOnDatastoreFault" - if ns0.RDMNotSupportedOnDatastore_Def not in ns0.RDMNotSupportedOnDatastoreFault_Dec.__bases__: - bases = list(ns0.RDMNotSupportedOnDatastoreFault_Dec.__bases__) - bases.insert(0, ns0.RDMNotSupportedOnDatastore_Def) - ns0.RDMNotSupportedOnDatastoreFault_Dec.__bases__ = tuple(bases) - - ns0.RDMNotSupportedOnDatastore_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RDMNotSupportedOnDatastoreFault_Dec_Holder" - - class RDMPointsToInaccessibleDiskFault_Dec(ElementDeclaration): - literal = "RDMPointsToInaccessibleDiskFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RDMPointsToInaccessibleDiskFault") - kw["aname"] = "_RDMPointsToInaccessibleDiskFault" - if ns0.RDMPointsToInaccessibleDisk_Def not in ns0.RDMPointsToInaccessibleDiskFault_Dec.__bases__: - bases = list(ns0.RDMPointsToInaccessibleDiskFault_Dec.__bases__) - bases.insert(0, ns0.RDMPointsToInaccessibleDisk_Def) - ns0.RDMPointsToInaccessibleDiskFault_Dec.__bases__ = tuple(bases) - - ns0.RDMPointsToInaccessibleDisk_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RDMPointsToInaccessibleDiskFault_Dec_Holder" - - class RawDiskNotSupportedFault_Dec(ElementDeclaration): - literal = "RawDiskNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RawDiskNotSupportedFault") - kw["aname"] = "_RawDiskNotSupportedFault" - if ns0.RawDiskNotSupported_Def not in ns0.RawDiskNotSupportedFault_Dec.__bases__: - bases = list(ns0.RawDiskNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.RawDiskNotSupported_Def) - ns0.RawDiskNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.RawDiskNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RawDiskNotSupportedFault_Dec_Holder" - - class ReadOnlyDisksWithLegacyDestinationFault_Dec(ElementDeclaration): - literal = "ReadOnlyDisksWithLegacyDestinationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReadOnlyDisksWithLegacyDestinationFault") - kw["aname"] = "_ReadOnlyDisksWithLegacyDestinationFault" - if ns0.ReadOnlyDisksWithLegacyDestination_Def not in ns0.ReadOnlyDisksWithLegacyDestinationFault_Dec.__bases__: - bases = list(ns0.ReadOnlyDisksWithLegacyDestinationFault_Dec.__bases__) - bases.insert(0, ns0.ReadOnlyDisksWithLegacyDestination_Def) - ns0.ReadOnlyDisksWithLegacyDestinationFault_Dec.__bases__ = tuple(bases) - - ns0.ReadOnlyDisksWithLegacyDestination_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReadOnlyDisksWithLegacyDestinationFault_Dec_Holder" - - class RebootRequiredFault_Dec(ElementDeclaration): - literal = "RebootRequiredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RebootRequiredFault") - kw["aname"] = "_RebootRequiredFault" - if ns0.RebootRequired_Def not in ns0.RebootRequiredFault_Dec.__bases__: - bases = list(ns0.RebootRequiredFault_Dec.__bases__) - bases.insert(0, ns0.RebootRequired_Def) - ns0.RebootRequiredFault_Dec.__bases__ = tuple(bases) - - ns0.RebootRequired_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RebootRequiredFault_Dec_Holder" - - class RecordReplayDisabledFault_Dec(ElementDeclaration): - literal = "RecordReplayDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RecordReplayDisabledFault") - kw["aname"] = "_RecordReplayDisabledFault" - if ns0.RecordReplayDisabled_Def not in ns0.RecordReplayDisabledFault_Dec.__bases__: - bases = list(ns0.RecordReplayDisabledFault_Dec.__bases__) - bases.insert(0, ns0.RecordReplayDisabled_Def) - ns0.RecordReplayDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.RecordReplayDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RecordReplayDisabledFault_Dec_Holder" - - class RemoteDeviceNotSupportedFault_Dec(ElementDeclaration): - literal = "RemoteDeviceNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoteDeviceNotSupportedFault") - kw["aname"] = "_RemoteDeviceNotSupportedFault" - if ns0.RemoteDeviceNotSupported_Def not in ns0.RemoteDeviceNotSupportedFault_Dec.__bases__: - bases = list(ns0.RemoteDeviceNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.RemoteDeviceNotSupported_Def) - ns0.RemoteDeviceNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.RemoteDeviceNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoteDeviceNotSupportedFault_Dec_Holder" - - class RemoveFailedFault_Dec(ElementDeclaration): - literal = "RemoveFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveFailedFault") - kw["aname"] = "_RemoveFailedFault" - if ns0.RemoveFailed_Def not in ns0.RemoveFailedFault_Dec.__bases__: - bases = list(ns0.RemoveFailedFault_Dec.__bases__) - bases.insert(0, ns0.RemoveFailed_Def) - ns0.RemoveFailedFault_Dec.__bases__ = tuple(bases) - - ns0.RemoveFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveFailedFault_Dec_Holder" - - class ResourceInUseFault_Dec(ElementDeclaration): - literal = "ResourceInUseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResourceInUseFault") - kw["aname"] = "_ResourceInUseFault" - if ns0.ResourceInUse_Def not in ns0.ResourceInUseFault_Dec.__bases__: - bases = list(ns0.ResourceInUseFault_Dec.__bases__) - bases.insert(0, ns0.ResourceInUse_Def) - ns0.ResourceInUseFault_Dec.__bases__ = tuple(bases) - - ns0.ResourceInUse_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResourceInUseFault_Dec_Holder" - - class ResourceNotAvailableFault_Dec(ElementDeclaration): - literal = "ResourceNotAvailableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResourceNotAvailableFault") - kw["aname"] = "_ResourceNotAvailableFault" - if ns0.ResourceNotAvailable_Def not in ns0.ResourceNotAvailableFault_Dec.__bases__: - bases = list(ns0.ResourceNotAvailableFault_Dec.__bases__) - bases.insert(0, ns0.ResourceNotAvailable_Def) - ns0.ResourceNotAvailableFault_Dec.__bases__ = tuple(bases) - - ns0.ResourceNotAvailable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResourceNotAvailableFault_Dec_Holder" - - class RestrictedVersionFault_Dec(ElementDeclaration): - literal = "RestrictedVersionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RestrictedVersionFault") - kw["aname"] = "_RestrictedVersionFault" - if ns0.RestrictedVersion_Def not in ns0.RestrictedVersionFault_Dec.__bases__: - bases = list(ns0.RestrictedVersionFault_Dec.__bases__) - bases.insert(0, ns0.RestrictedVersion_Def) - ns0.RestrictedVersionFault_Dec.__bases__ = tuple(bases) - - ns0.RestrictedVersion_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RestrictedVersionFault_Dec_Holder" - - class RuleViolationFault_Dec(ElementDeclaration): - literal = "RuleViolationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RuleViolationFault") - kw["aname"] = "_RuleViolationFault" - if ns0.RuleViolation_Def not in ns0.RuleViolationFault_Dec.__bases__: - bases = list(ns0.RuleViolationFault_Dec.__bases__) - bases.insert(0, ns0.RuleViolation_Def) - ns0.RuleViolationFault_Dec.__bases__ = tuple(bases) - - ns0.RuleViolation_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RuleViolationFault_Dec_Holder" - - class SSLDisabledFaultFault_Dec(ElementDeclaration): - literal = "SSLDisabledFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SSLDisabledFaultFault") - kw["aname"] = "_SSLDisabledFaultFault" - if ns0.SSLDisabledFault_Def not in ns0.SSLDisabledFaultFault_Dec.__bases__: - bases = list(ns0.SSLDisabledFaultFault_Dec.__bases__) - bases.insert(0, ns0.SSLDisabledFault_Def) - ns0.SSLDisabledFaultFault_Dec.__bases__ = tuple(bases) - - ns0.SSLDisabledFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SSLDisabledFaultFault_Dec_Holder" - - class SSLVerifyFaultFault_Dec(ElementDeclaration): - literal = "SSLVerifyFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SSLVerifyFaultFault") - kw["aname"] = "_SSLVerifyFaultFault" - if ns0.SSLVerifyFault_Def not in ns0.SSLVerifyFaultFault_Dec.__bases__: - bases = list(ns0.SSLVerifyFaultFault_Dec.__bases__) - bases.insert(0, ns0.SSLVerifyFault_Def) - ns0.SSLVerifyFaultFault_Dec.__bases__ = tuple(bases) - - ns0.SSLVerifyFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SSLVerifyFaultFault_Dec_Holder" - - class SSPIChallengeFault_Dec(ElementDeclaration): - literal = "SSPIChallengeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SSPIChallengeFault") - kw["aname"] = "_SSPIChallengeFault" - if ns0.SSPIChallenge_Def not in ns0.SSPIChallengeFault_Dec.__bases__: - bases = list(ns0.SSPIChallengeFault_Dec.__bases__) - bases.insert(0, ns0.SSPIChallenge_Def) - ns0.SSPIChallengeFault_Dec.__bases__ = tuple(bases) - - ns0.SSPIChallenge_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SSPIChallengeFault_Dec_Holder" - - class SecondaryVmAlreadyDisabledFault_Dec(ElementDeclaration): - literal = "SecondaryVmAlreadyDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SecondaryVmAlreadyDisabledFault") - kw["aname"] = "_SecondaryVmAlreadyDisabledFault" - if ns0.SecondaryVmAlreadyDisabled_Def not in ns0.SecondaryVmAlreadyDisabledFault_Dec.__bases__: - bases = list(ns0.SecondaryVmAlreadyDisabledFault_Dec.__bases__) - bases.insert(0, ns0.SecondaryVmAlreadyDisabled_Def) - ns0.SecondaryVmAlreadyDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.SecondaryVmAlreadyDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmAlreadyDisabledFault_Dec_Holder" - - class SecondaryVmAlreadyEnabledFault_Dec(ElementDeclaration): - literal = "SecondaryVmAlreadyEnabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SecondaryVmAlreadyEnabledFault") - kw["aname"] = "_SecondaryVmAlreadyEnabledFault" - if ns0.SecondaryVmAlreadyEnabled_Def not in ns0.SecondaryVmAlreadyEnabledFault_Dec.__bases__: - bases = list(ns0.SecondaryVmAlreadyEnabledFault_Dec.__bases__) - bases.insert(0, ns0.SecondaryVmAlreadyEnabled_Def) - ns0.SecondaryVmAlreadyEnabledFault_Dec.__bases__ = tuple(bases) - - ns0.SecondaryVmAlreadyEnabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmAlreadyEnabledFault_Dec_Holder" - - class SecondaryVmAlreadyRegisteredFault_Dec(ElementDeclaration): - literal = "SecondaryVmAlreadyRegisteredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SecondaryVmAlreadyRegisteredFault") - kw["aname"] = "_SecondaryVmAlreadyRegisteredFault" - if ns0.SecondaryVmAlreadyRegistered_Def not in ns0.SecondaryVmAlreadyRegisteredFault_Dec.__bases__: - bases = list(ns0.SecondaryVmAlreadyRegisteredFault_Dec.__bases__) - bases.insert(0, ns0.SecondaryVmAlreadyRegistered_Def) - ns0.SecondaryVmAlreadyRegisteredFault_Dec.__bases__ = tuple(bases) - - ns0.SecondaryVmAlreadyRegistered_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmAlreadyRegisteredFault_Dec_Holder" - - class SecondaryVmNotRegisteredFault_Dec(ElementDeclaration): - literal = "SecondaryVmNotRegisteredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SecondaryVmNotRegisteredFault") - kw["aname"] = "_SecondaryVmNotRegisteredFault" - if ns0.SecondaryVmNotRegistered_Def not in ns0.SecondaryVmNotRegisteredFault_Dec.__bases__: - bases = list(ns0.SecondaryVmNotRegisteredFault_Dec.__bases__) - bases.insert(0, ns0.SecondaryVmNotRegistered_Def) - ns0.SecondaryVmNotRegisteredFault_Dec.__bases__ = tuple(bases) - - ns0.SecondaryVmNotRegistered_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SecondaryVmNotRegisteredFault_Dec_Holder" - - class SharedBusControllerNotSupportedFault_Dec(ElementDeclaration): - literal = "SharedBusControllerNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SharedBusControllerNotSupportedFault") - kw["aname"] = "_SharedBusControllerNotSupportedFault" - if ns0.SharedBusControllerNotSupported_Def not in ns0.SharedBusControllerNotSupportedFault_Dec.__bases__: - bases = list(ns0.SharedBusControllerNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SharedBusControllerNotSupported_Def) - ns0.SharedBusControllerNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SharedBusControllerNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SharedBusControllerNotSupportedFault_Dec_Holder" - - class SnapshotCloneNotSupportedFault_Dec(ElementDeclaration): - literal = "SnapshotCloneNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotCloneNotSupportedFault") - kw["aname"] = "_SnapshotCloneNotSupportedFault" - if ns0.SnapshotCloneNotSupported_Def not in ns0.SnapshotCloneNotSupportedFault_Dec.__bases__: - bases = list(ns0.SnapshotCloneNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotCloneNotSupported_Def) - ns0.SnapshotCloneNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotCloneNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotCloneNotSupportedFault_Dec_Holder" - - class SnapshotCopyNotSupportedFault_Dec(ElementDeclaration): - literal = "SnapshotCopyNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotCopyNotSupportedFault") - kw["aname"] = "_SnapshotCopyNotSupportedFault" - if ns0.SnapshotCopyNotSupported_Def not in ns0.SnapshotCopyNotSupportedFault_Dec.__bases__: - bases = list(ns0.SnapshotCopyNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotCopyNotSupported_Def) - ns0.SnapshotCopyNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotCopyNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotCopyNotSupportedFault_Dec_Holder" - - class SnapshotDisabledFault_Dec(ElementDeclaration): - literal = "SnapshotDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotDisabledFault") - kw["aname"] = "_SnapshotDisabledFault" - if ns0.SnapshotDisabled_Def not in ns0.SnapshotDisabledFault_Dec.__bases__: - bases = list(ns0.SnapshotDisabledFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotDisabled_Def) - ns0.SnapshotDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotDisabledFault_Dec_Holder" - - class SnapshotFaultFault_Dec(ElementDeclaration): - literal = "SnapshotFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotFaultFault") - kw["aname"] = "_SnapshotFaultFault" - if ns0.SnapshotFault_Def not in ns0.SnapshotFaultFault_Dec.__bases__: - bases = list(ns0.SnapshotFaultFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotFault_Def) - ns0.SnapshotFaultFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotFaultFault_Dec_Holder" - - class SnapshotIncompatibleDeviceInVmFault_Dec(ElementDeclaration): - literal = "SnapshotIncompatibleDeviceInVmFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotIncompatibleDeviceInVmFault") - kw["aname"] = "_SnapshotIncompatibleDeviceInVmFault" - if ns0.SnapshotIncompatibleDeviceInVm_Def not in ns0.SnapshotIncompatibleDeviceInVmFault_Dec.__bases__: - bases = list(ns0.SnapshotIncompatibleDeviceInVmFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotIncompatibleDeviceInVm_Def) - ns0.SnapshotIncompatibleDeviceInVmFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotIncompatibleDeviceInVm_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotIncompatibleDeviceInVmFault_Dec_Holder" - - class SnapshotLockedFault_Dec(ElementDeclaration): - literal = "SnapshotLockedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotLockedFault") - kw["aname"] = "_SnapshotLockedFault" - if ns0.SnapshotLocked_Def not in ns0.SnapshotLockedFault_Dec.__bases__: - bases = list(ns0.SnapshotLockedFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotLocked_Def) - ns0.SnapshotLockedFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotLocked_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotLockedFault_Dec_Holder" - - class SnapshotMoveFromNonHomeNotSupportedFault_Dec(ElementDeclaration): - literal = "SnapshotMoveFromNonHomeNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotMoveFromNonHomeNotSupportedFault") - kw["aname"] = "_SnapshotMoveFromNonHomeNotSupportedFault" - if ns0.SnapshotMoveFromNonHomeNotSupported_Def not in ns0.SnapshotMoveFromNonHomeNotSupportedFault_Dec.__bases__: - bases = list(ns0.SnapshotMoveFromNonHomeNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotMoveFromNonHomeNotSupported_Def) - ns0.SnapshotMoveFromNonHomeNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotMoveFromNonHomeNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotMoveFromNonHomeNotSupportedFault_Dec_Holder" - - class SnapshotMoveNotSupportedFault_Dec(ElementDeclaration): - literal = "SnapshotMoveNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotMoveNotSupportedFault") - kw["aname"] = "_SnapshotMoveNotSupportedFault" - if ns0.SnapshotMoveNotSupported_Def not in ns0.SnapshotMoveNotSupportedFault_Dec.__bases__: - bases = list(ns0.SnapshotMoveNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotMoveNotSupported_Def) - ns0.SnapshotMoveNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotMoveNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotMoveNotSupportedFault_Dec_Holder" - - class SnapshotMoveToNonHomeNotSupportedFault_Dec(ElementDeclaration): - literal = "SnapshotMoveToNonHomeNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotMoveToNonHomeNotSupportedFault") - kw["aname"] = "_SnapshotMoveToNonHomeNotSupportedFault" - if ns0.SnapshotMoveToNonHomeNotSupported_Def not in ns0.SnapshotMoveToNonHomeNotSupportedFault_Dec.__bases__: - bases = list(ns0.SnapshotMoveToNonHomeNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotMoveToNonHomeNotSupported_Def) - ns0.SnapshotMoveToNonHomeNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotMoveToNonHomeNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotMoveToNonHomeNotSupportedFault_Dec_Holder" - - class SnapshotNoChangeFault_Dec(ElementDeclaration): - literal = "SnapshotNoChangeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotNoChangeFault") - kw["aname"] = "_SnapshotNoChangeFault" - if ns0.SnapshotNoChange_Def not in ns0.SnapshotNoChangeFault_Dec.__bases__: - bases = list(ns0.SnapshotNoChangeFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotNoChange_Def) - ns0.SnapshotNoChangeFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotNoChange_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotNoChangeFault_Dec_Holder" - - class SnapshotRevertIssueFault_Dec(ElementDeclaration): - literal = "SnapshotRevertIssueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SnapshotRevertIssueFault") - kw["aname"] = "_SnapshotRevertIssueFault" - if ns0.SnapshotRevertIssue_Def not in ns0.SnapshotRevertIssueFault_Dec.__bases__: - bases = list(ns0.SnapshotRevertIssueFault_Dec.__bases__) - bases.insert(0, ns0.SnapshotRevertIssue_Def) - ns0.SnapshotRevertIssueFault_Dec.__bases__ = tuple(bases) - - ns0.SnapshotRevertIssue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SnapshotRevertIssueFault_Dec_Holder" - - class StorageVMotionNotSupportedFault_Dec(ElementDeclaration): - literal = "StorageVMotionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StorageVMotionNotSupportedFault") - kw["aname"] = "_StorageVMotionNotSupportedFault" - if ns0.StorageVMotionNotSupported_Def not in ns0.StorageVMotionNotSupportedFault_Dec.__bases__: - bases = list(ns0.StorageVMotionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.StorageVMotionNotSupported_Def) - ns0.StorageVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.StorageVMotionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StorageVMotionNotSupportedFault_Dec_Holder" - - class SuspendedRelocateNotSupportedFault_Dec(ElementDeclaration): - literal = "SuspendedRelocateNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SuspendedRelocateNotSupportedFault") - kw["aname"] = "_SuspendedRelocateNotSupportedFault" - if ns0.SuspendedRelocateNotSupported_Def not in ns0.SuspendedRelocateNotSupportedFault_Dec.__bases__: - bases = list(ns0.SuspendedRelocateNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SuspendedRelocateNotSupported_Def) - ns0.SuspendedRelocateNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SuspendedRelocateNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SuspendedRelocateNotSupportedFault_Dec_Holder" - - class SwapDatastoreNotWritableOnHostFault_Dec(ElementDeclaration): - literal = "SwapDatastoreNotWritableOnHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SwapDatastoreNotWritableOnHostFault") - kw["aname"] = "_SwapDatastoreNotWritableOnHostFault" - if ns0.SwapDatastoreNotWritableOnHost_Def not in ns0.SwapDatastoreNotWritableOnHostFault_Dec.__bases__: - bases = list(ns0.SwapDatastoreNotWritableOnHostFault_Dec.__bases__) - bases.insert(0, ns0.SwapDatastoreNotWritableOnHost_Def) - ns0.SwapDatastoreNotWritableOnHostFault_Dec.__bases__ = tuple(bases) - - ns0.SwapDatastoreNotWritableOnHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SwapDatastoreNotWritableOnHostFault_Dec_Holder" - - class SwapDatastoreUnsetFault_Dec(ElementDeclaration): - literal = "SwapDatastoreUnsetFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SwapDatastoreUnsetFault") - kw["aname"] = "_SwapDatastoreUnsetFault" - if ns0.SwapDatastoreUnset_Def not in ns0.SwapDatastoreUnsetFault_Dec.__bases__: - bases = list(ns0.SwapDatastoreUnsetFault_Dec.__bases__) - bases.insert(0, ns0.SwapDatastoreUnset_Def) - ns0.SwapDatastoreUnsetFault_Dec.__bases__ = tuple(bases) - - ns0.SwapDatastoreUnset_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SwapDatastoreUnsetFault_Dec_Holder" - - class SwapPlacementOverrideNotSupportedFault_Dec(ElementDeclaration): - literal = "SwapPlacementOverrideNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SwapPlacementOverrideNotSupportedFault") - kw["aname"] = "_SwapPlacementOverrideNotSupportedFault" - if ns0.SwapPlacementOverrideNotSupported_Def not in ns0.SwapPlacementOverrideNotSupportedFault_Dec.__bases__: - bases = list(ns0.SwapPlacementOverrideNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.SwapPlacementOverrideNotSupported_Def) - ns0.SwapPlacementOverrideNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.SwapPlacementOverrideNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SwapPlacementOverrideNotSupportedFault_Dec_Holder" - - class SwitchNotInUpgradeModeFault_Dec(ElementDeclaration): - literal = "SwitchNotInUpgradeModeFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SwitchNotInUpgradeModeFault") - kw["aname"] = "_SwitchNotInUpgradeModeFault" - if ns0.SwitchNotInUpgradeMode_Def not in ns0.SwitchNotInUpgradeModeFault_Dec.__bases__: - bases = list(ns0.SwitchNotInUpgradeModeFault_Dec.__bases__) - bases.insert(0, ns0.SwitchNotInUpgradeMode_Def) - ns0.SwitchNotInUpgradeModeFault_Dec.__bases__ = tuple(bases) - - ns0.SwitchNotInUpgradeMode_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SwitchNotInUpgradeModeFault_Dec_Holder" - - class TaskInProgressFault_Dec(ElementDeclaration): - literal = "TaskInProgressFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TaskInProgressFault") - kw["aname"] = "_TaskInProgressFault" - if ns0.TaskInProgress_Def not in ns0.TaskInProgressFault_Dec.__bases__: - bases = list(ns0.TaskInProgressFault_Dec.__bases__) - bases.insert(0, ns0.TaskInProgress_Def) - ns0.TaskInProgressFault_Dec.__bases__ = tuple(bases) - - ns0.TaskInProgress_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TaskInProgressFault_Dec_Holder" - - class TimedoutFault_Dec(ElementDeclaration): - literal = "TimedoutFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TimedoutFault") - kw["aname"] = "_TimedoutFault" - if ns0.Timedout_Def not in ns0.TimedoutFault_Dec.__bases__: - bases = list(ns0.TimedoutFault_Dec.__bases__) - bases.insert(0, ns0.Timedout_Def) - ns0.TimedoutFault_Dec.__bases__ = tuple(bases) - - ns0.Timedout_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TimedoutFault_Dec_Holder" - - class TooManyConsecutiveOverridesFault_Dec(ElementDeclaration): - literal = "TooManyConsecutiveOverridesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TooManyConsecutiveOverridesFault") - kw["aname"] = "_TooManyConsecutiveOverridesFault" - if ns0.TooManyConsecutiveOverrides_Def not in ns0.TooManyConsecutiveOverridesFault_Dec.__bases__: - bases = list(ns0.TooManyConsecutiveOverridesFault_Dec.__bases__) - bases.insert(0, ns0.TooManyConsecutiveOverrides_Def) - ns0.TooManyConsecutiveOverridesFault_Dec.__bases__ = tuple(bases) - - ns0.TooManyConsecutiveOverrides_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TooManyConsecutiveOverridesFault_Dec_Holder" - - class TooManyDevicesFault_Dec(ElementDeclaration): - literal = "TooManyDevicesFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TooManyDevicesFault") - kw["aname"] = "_TooManyDevicesFault" - if ns0.TooManyDevices_Def not in ns0.TooManyDevicesFault_Dec.__bases__: - bases = list(ns0.TooManyDevicesFault_Dec.__bases__) - bases.insert(0, ns0.TooManyDevices_Def) - ns0.TooManyDevicesFault_Dec.__bases__ = tuple(bases) - - ns0.TooManyDevices_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TooManyDevicesFault_Dec_Holder" - - class TooManyDisksOnLegacyHostFault_Dec(ElementDeclaration): - literal = "TooManyDisksOnLegacyHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TooManyDisksOnLegacyHostFault") - kw["aname"] = "_TooManyDisksOnLegacyHostFault" - if ns0.TooManyDisksOnLegacyHost_Def not in ns0.TooManyDisksOnLegacyHostFault_Dec.__bases__: - bases = list(ns0.TooManyDisksOnLegacyHostFault_Dec.__bases__) - bases.insert(0, ns0.TooManyDisksOnLegacyHost_Def) - ns0.TooManyDisksOnLegacyHostFault_Dec.__bases__ = tuple(bases) - - ns0.TooManyDisksOnLegacyHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TooManyDisksOnLegacyHostFault_Dec_Holder" - - class TooManyHostsFault_Dec(ElementDeclaration): - literal = "TooManyHostsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TooManyHostsFault") - kw["aname"] = "_TooManyHostsFault" - if ns0.TooManyHosts_Def not in ns0.TooManyHostsFault_Dec.__bases__: - bases = list(ns0.TooManyHostsFault_Dec.__bases__) - bases.insert(0, ns0.TooManyHosts_Def) - ns0.TooManyHostsFault_Dec.__bases__ = tuple(bases) - - ns0.TooManyHosts_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TooManyHostsFault_Dec_Holder" - - class TooManySnapshotLevelsFault_Dec(ElementDeclaration): - literal = "TooManySnapshotLevelsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","TooManySnapshotLevelsFault") - kw["aname"] = "_TooManySnapshotLevelsFault" - if ns0.TooManySnapshotLevels_Def not in ns0.TooManySnapshotLevelsFault_Dec.__bases__: - bases = list(ns0.TooManySnapshotLevelsFault_Dec.__bases__) - bases.insert(0, ns0.TooManySnapshotLevels_Def) - ns0.TooManySnapshotLevelsFault_Dec.__bases__ = tuple(bases) - - ns0.TooManySnapshotLevels_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "TooManySnapshotLevelsFault_Dec_Holder" - - class ToolsAlreadyUpgradedFault_Dec(ElementDeclaration): - literal = "ToolsAlreadyUpgradedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ToolsAlreadyUpgradedFault") - kw["aname"] = "_ToolsAlreadyUpgradedFault" - if ns0.ToolsAlreadyUpgraded_Def not in ns0.ToolsAlreadyUpgradedFault_Dec.__bases__: - bases = list(ns0.ToolsAlreadyUpgradedFault_Dec.__bases__) - bases.insert(0, ns0.ToolsAlreadyUpgraded_Def) - ns0.ToolsAlreadyUpgradedFault_Dec.__bases__ = tuple(bases) - - ns0.ToolsAlreadyUpgraded_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ToolsAlreadyUpgradedFault_Dec_Holder" - - class ToolsAutoUpgradeNotSupportedFault_Dec(ElementDeclaration): - literal = "ToolsAutoUpgradeNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ToolsAutoUpgradeNotSupportedFault") - kw["aname"] = "_ToolsAutoUpgradeNotSupportedFault" - if ns0.ToolsAutoUpgradeNotSupported_Def not in ns0.ToolsAutoUpgradeNotSupportedFault_Dec.__bases__: - bases = list(ns0.ToolsAutoUpgradeNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.ToolsAutoUpgradeNotSupported_Def) - ns0.ToolsAutoUpgradeNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.ToolsAutoUpgradeNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ToolsAutoUpgradeNotSupportedFault_Dec_Holder" - - class ToolsImageNotAvailableFault_Dec(ElementDeclaration): - literal = "ToolsImageNotAvailableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ToolsImageNotAvailableFault") - kw["aname"] = "_ToolsImageNotAvailableFault" - if ns0.ToolsImageNotAvailable_Def not in ns0.ToolsImageNotAvailableFault_Dec.__bases__: - bases = list(ns0.ToolsImageNotAvailableFault_Dec.__bases__) - bases.insert(0, ns0.ToolsImageNotAvailable_Def) - ns0.ToolsImageNotAvailableFault_Dec.__bases__ = tuple(bases) - - ns0.ToolsImageNotAvailable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ToolsImageNotAvailableFault_Dec_Holder" - - class ToolsImageSignatureCheckFailedFault_Dec(ElementDeclaration): - literal = "ToolsImageSignatureCheckFailedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ToolsImageSignatureCheckFailedFault") - kw["aname"] = "_ToolsImageSignatureCheckFailedFault" - if ns0.ToolsImageSignatureCheckFailed_Def not in ns0.ToolsImageSignatureCheckFailedFault_Dec.__bases__: - bases = list(ns0.ToolsImageSignatureCheckFailedFault_Dec.__bases__) - bases.insert(0, ns0.ToolsImageSignatureCheckFailed_Def) - ns0.ToolsImageSignatureCheckFailedFault_Dec.__bases__ = tuple(bases) - - ns0.ToolsImageSignatureCheckFailed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ToolsImageSignatureCheckFailedFault_Dec_Holder" - - class ToolsInstallationInProgressFault_Dec(ElementDeclaration): - literal = "ToolsInstallationInProgressFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ToolsInstallationInProgressFault") - kw["aname"] = "_ToolsInstallationInProgressFault" - if ns0.ToolsInstallationInProgress_Def not in ns0.ToolsInstallationInProgressFault_Dec.__bases__: - bases = list(ns0.ToolsInstallationInProgressFault_Dec.__bases__) - bases.insert(0, ns0.ToolsInstallationInProgress_Def) - ns0.ToolsInstallationInProgressFault_Dec.__bases__ = tuple(bases) - - ns0.ToolsInstallationInProgress_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ToolsInstallationInProgressFault_Dec_Holder" - - class ToolsUnavailableFault_Dec(ElementDeclaration): - literal = "ToolsUnavailableFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ToolsUnavailableFault") - kw["aname"] = "_ToolsUnavailableFault" - if ns0.ToolsUnavailable_Def not in ns0.ToolsUnavailableFault_Dec.__bases__: - bases = list(ns0.ToolsUnavailableFault_Dec.__bases__) - bases.insert(0, ns0.ToolsUnavailable_Def) - ns0.ToolsUnavailableFault_Dec.__bases__ = tuple(bases) - - ns0.ToolsUnavailable_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ToolsUnavailableFault_Dec_Holder" - - class ToolsUpgradeCancelledFault_Dec(ElementDeclaration): - literal = "ToolsUpgradeCancelledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ToolsUpgradeCancelledFault") - kw["aname"] = "_ToolsUpgradeCancelledFault" - if ns0.ToolsUpgradeCancelled_Def not in ns0.ToolsUpgradeCancelledFault_Dec.__bases__: - bases = list(ns0.ToolsUpgradeCancelledFault_Dec.__bases__) - bases.insert(0, ns0.ToolsUpgradeCancelled_Def) - ns0.ToolsUpgradeCancelledFault_Dec.__bases__ = tuple(bases) - - ns0.ToolsUpgradeCancelled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ToolsUpgradeCancelledFault_Dec_Holder" - - class UncommittedUndoableDiskFault_Dec(ElementDeclaration): - literal = "UncommittedUndoableDiskFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UncommittedUndoableDiskFault") - kw["aname"] = "_UncommittedUndoableDiskFault" - if ns0.UncommittedUndoableDisk_Def not in ns0.UncommittedUndoableDiskFault_Dec.__bases__: - bases = list(ns0.UncommittedUndoableDiskFault_Dec.__bases__) - bases.insert(0, ns0.UncommittedUndoableDisk_Def) - ns0.UncommittedUndoableDiskFault_Dec.__bases__ = tuple(bases) - - ns0.UncommittedUndoableDisk_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UncommittedUndoableDiskFault_Dec_Holder" - - class UnconfiguredPropertyValueFault_Dec(ElementDeclaration): - literal = "UnconfiguredPropertyValueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnconfiguredPropertyValueFault") - kw["aname"] = "_UnconfiguredPropertyValueFault" - if ns0.UnconfiguredPropertyValue_Def not in ns0.UnconfiguredPropertyValueFault_Dec.__bases__: - bases = list(ns0.UnconfiguredPropertyValueFault_Dec.__bases__) - bases.insert(0, ns0.UnconfiguredPropertyValue_Def) - ns0.UnconfiguredPropertyValueFault_Dec.__bases__ = tuple(bases) - - ns0.UnconfiguredPropertyValue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnconfiguredPropertyValueFault_Dec_Holder" - - class UncustomizableGuestFault_Dec(ElementDeclaration): - literal = "UncustomizableGuestFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UncustomizableGuestFault") - kw["aname"] = "_UncustomizableGuestFault" - if ns0.UncustomizableGuest_Def not in ns0.UncustomizableGuestFault_Dec.__bases__: - bases = list(ns0.UncustomizableGuestFault_Dec.__bases__) - bases.insert(0, ns0.UncustomizableGuest_Def) - ns0.UncustomizableGuestFault_Dec.__bases__ = tuple(bases) - - ns0.UncustomizableGuest_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UncustomizableGuestFault_Dec_Holder" - - class UnexpectedCustomizationFaultFault_Dec(ElementDeclaration): - literal = "UnexpectedCustomizationFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnexpectedCustomizationFaultFault") - kw["aname"] = "_UnexpectedCustomizationFaultFault" - if ns0.UnexpectedCustomizationFault_Def not in ns0.UnexpectedCustomizationFaultFault_Dec.__bases__: - bases = list(ns0.UnexpectedCustomizationFaultFault_Dec.__bases__) - bases.insert(0, ns0.UnexpectedCustomizationFault_Def) - ns0.UnexpectedCustomizationFaultFault_Dec.__bases__ = tuple(bases) - - ns0.UnexpectedCustomizationFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnexpectedCustomizationFaultFault_Dec_Holder" - - class UnrecognizedHostFault_Dec(ElementDeclaration): - literal = "UnrecognizedHostFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnrecognizedHostFault") - kw["aname"] = "_UnrecognizedHostFault" - if ns0.UnrecognizedHost_Def not in ns0.UnrecognizedHostFault_Dec.__bases__: - bases = list(ns0.UnrecognizedHostFault_Dec.__bases__) - bases.insert(0, ns0.UnrecognizedHost_Def) - ns0.UnrecognizedHostFault_Dec.__bases__ = tuple(bases) - - ns0.UnrecognizedHost_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnrecognizedHostFault_Dec_Holder" - - class UnsharedSwapVMotionNotSupportedFault_Dec(ElementDeclaration): - literal = "UnsharedSwapVMotionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnsharedSwapVMotionNotSupportedFault") - kw["aname"] = "_UnsharedSwapVMotionNotSupportedFault" - if ns0.UnsharedSwapVMotionNotSupported_Def not in ns0.UnsharedSwapVMotionNotSupportedFault_Dec.__bases__: - bases = list(ns0.UnsharedSwapVMotionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.UnsharedSwapVMotionNotSupported_Def) - ns0.UnsharedSwapVMotionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.UnsharedSwapVMotionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnsharedSwapVMotionNotSupportedFault_Dec_Holder" - - class UnsupportedDatastoreFault_Dec(ElementDeclaration): - literal = "UnsupportedDatastoreFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnsupportedDatastoreFault") - kw["aname"] = "_UnsupportedDatastoreFault" - if ns0.UnsupportedDatastore_Def not in ns0.UnsupportedDatastoreFault_Dec.__bases__: - bases = list(ns0.UnsupportedDatastoreFault_Dec.__bases__) - bases.insert(0, ns0.UnsupportedDatastore_Def) - ns0.UnsupportedDatastoreFault_Dec.__bases__ = tuple(bases) - - ns0.UnsupportedDatastore_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedDatastoreFault_Dec_Holder" - - class UnsupportedGuestFault_Dec(ElementDeclaration): - literal = "UnsupportedGuestFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnsupportedGuestFault") - kw["aname"] = "_UnsupportedGuestFault" - if ns0.UnsupportedGuest_Def not in ns0.UnsupportedGuestFault_Dec.__bases__: - bases = list(ns0.UnsupportedGuestFault_Dec.__bases__) - bases.insert(0, ns0.UnsupportedGuest_Def) - ns0.UnsupportedGuestFault_Dec.__bases__ = tuple(bases) - - ns0.UnsupportedGuest_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedGuestFault_Dec_Holder" - - class UnsupportedVimApiVersionFault_Dec(ElementDeclaration): - literal = "UnsupportedVimApiVersionFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnsupportedVimApiVersionFault") - kw["aname"] = "_UnsupportedVimApiVersionFault" - if ns0.UnsupportedVimApiVersion_Def not in ns0.UnsupportedVimApiVersionFault_Dec.__bases__: - bases = list(ns0.UnsupportedVimApiVersionFault_Dec.__bases__) - bases.insert(0, ns0.UnsupportedVimApiVersion_Def) - ns0.UnsupportedVimApiVersionFault_Dec.__bases__ = tuple(bases) - - ns0.UnsupportedVimApiVersion_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedVimApiVersionFault_Dec_Holder" - - class UnsupportedVmxLocationFault_Dec(ElementDeclaration): - literal = "UnsupportedVmxLocationFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnsupportedVmxLocationFault") - kw["aname"] = "_UnsupportedVmxLocationFault" - if ns0.UnsupportedVmxLocation_Def not in ns0.UnsupportedVmxLocationFault_Dec.__bases__: - bases = list(ns0.UnsupportedVmxLocationFault_Dec.__bases__) - bases.insert(0, ns0.UnsupportedVmxLocation_Def) - ns0.UnsupportedVmxLocationFault_Dec.__bases__ = tuple(bases) - - ns0.UnsupportedVmxLocation_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnsupportedVmxLocationFault_Dec_Holder" - - class UnusedVirtualDiskBlocksNotScrubbedFault_Dec(ElementDeclaration): - literal = "UnusedVirtualDiskBlocksNotScrubbedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnusedVirtualDiskBlocksNotScrubbedFault") - kw["aname"] = "_UnusedVirtualDiskBlocksNotScrubbedFault" - if ns0.UnusedVirtualDiskBlocksNotScrubbed_Def not in ns0.UnusedVirtualDiskBlocksNotScrubbedFault_Dec.__bases__: - bases = list(ns0.UnusedVirtualDiskBlocksNotScrubbedFault_Dec.__bases__) - bases.insert(0, ns0.UnusedVirtualDiskBlocksNotScrubbed_Def) - ns0.UnusedVirtualDiskBlocksNotScrubbedFault_Dec.__bases__ = tuple(bases) - - ns0.UnusedVirtualDiskBlocksNotScrubbed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnusedVirtualDiskBlocksNotScrubbedFault_Dec_Holder" - - class UserNotFoundFault_Dec(ElementDeclaration): - literal = "UserNotFoundFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UserNotFoundFault") - kw["aname"] = "_UserNotFoundFault" - if ns0.UserNotFound_Def not in ns0.UserNotFoundFault_Dec.__bases__: - bases = list(ns0.UserNotFoundFault_Dec.__bases__) - bases.insert(0, ns0.UserNotFound_Def) - ns0.UserNotFoundFault_Dec.__bases__ = tuple(bases) - - ns0.UserNotFound_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UserNotFoundFault_Dec_Holder" - - class VAppConfigFaultFault_Dec(ElementDeclaration): - literal = "VAppConfigFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VAppConfigFaultFault") - kw["aname"] = "_VAppConfigFaultFault" - if ns0.VAppConfigFault_Def not in ns0.VAppConfigFaultFault_Dec.__bases__: - bases = list(ns0.VAppConfigFaultFault_Dec.__bases__) - bases.insert(0, ns0.VAppConfigFault_Def) - ns0.VAppConfigFaultFault_Dec.__bases__ = tuple(bases) - - ns0.VAppConfigFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VAppConfigFaultFault_Dec_Holder" - - class VAppNotRunningFault_Dec(ElementDeclaration): - literal = "VAppNotRunningFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VAppNotRunningFault") - kw["aname"] = "_VAppNotRunningFault" - if ns0.VAppNotRunning_Def not in ns0.VAppNotRunningFault_Dec.__bases__: - bases = list(ns0.VAppNotRunningFault_Dec.__bases__) - bases.insert(0, ns0.VAppNotRunning_Def) - ns0.VAppNotRunningFault_Dec.__bases__ = tuple(bases) - - ns0.VAppNotRunning_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VAppNotRunningFault_Dec_Holder" - - class VAppPropertyFaultFault_Dec(ElementDeclaration): - literal = "VAppPropertyFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VAppPropertyFaultFault") - kw["aname"] = "_VAppPropertyFaultFault" - if ns0.VAppPropertyFault_Def not in ns0.VAppPropertyFaultFault_Dec.__bases__: - bases = list(ns0.VAppPropertyFaultFault_Dec.__bases__) - bases.insert(0, ns0.VAppPropertyFault_Def) - ns0.VAppPropertyFaultFault_Dec.__bases__ = tuple(bases) - - ns0.VAppPropertyFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VAppPropertyFaultFault_Dec_Holder" - - class VAppTaskInProgressFault_Dec(ElementDeclaration): - literal = "VAppTaskInProgressFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VAppTaskInProgressFault") - kw["aname"] = "_VAppTaskInProgressFault" - if ns0.VAppTaskInProgress_Def not in ns0.VAppTaskInProgressFault_Dec.__bases__: - bases = list(ns0.VAppTaskInProgressFault_Dec.__bases__) - bases.insert(0, ns0.VAppTaskInProgress_Def) - ns0.VAppTaskInProgressFault_Dec.__bases__ = tuple(bases) - - ns0.VAppTaskInProgress_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VAppTaskInProgressFault_Dec_Holder" - - class VMINotSupportedFault_Dec(ElementDeclaration): - literal = "VMINotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMINotSupportedFault") - kw["aname"] = "_VMINotSupportedFault" - if ns0.VMINotSupported_Def not in ns0.VMINotSupportedFault_Dec.__bases__: - bases = list(ns0.VMINotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.VMINotSupported_Def) - ns0.VMINotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.VMINotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMINotSupportedFault_Dec_Holder" - - class VMOnConflictDVPortFault_Dec(ElementDeclaration): - literal = "VMOnConflictDVPortFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMOnConflictDVPortFault") - kw["aname"] = "_VMOnConflictDVPortFault" - if ns0.VMOnConflictDVPort_Def not in ns0.VMOnConflictDVPortFault_Dec.__bases__: - bases = list(ns0.VMOnConflictDVPortFault_Dec.__bases__) - bases.insert(0, ns0.VMOnConflictDVPort_Def) - ns0.VMOnConflictDVPortFault_Dec.__bases__ = tuple(bases) - - ns0.VMOnConflictDVPort_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMOnConflictDVPortFault_Dec_Holder" - - class VMOnVirtualIntranetFault_Dec(ElementDeclaration): - literal = "VMOnVirtualIntranetFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMOnVirtualIntranetFault") - kw["aname"] = "_VMOnVirtualIntranetFault" - if ns0.VMOnVirtualIntranet_Def not in ns0.VMOnVirtualIntranetFault_Dec.__bases__: - bases = list(ns0.VMOnVirtualIntranetFault_Dec.__bases__) - bases.insert(0, ns0.VMOnVirtualIntranet_Def) - ns0.VMOnVirtualIntranetFault_Dec.__bases__ = tuple(bases) - - ns0.VMOnVirtualIntranet_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMOnVirtualIntranetFault_Dec_Holder" - - class VMotionInterfaceIssueFault_Dec(ElementDeclaration): - literal = "VMotionInterfaceIssueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMotionInterfaceIssueFault") - kw["aname"] = "_VMotionInterfaceIssueFault" - if ns0.VMotionInterfaceIssue_Def not in ns0.VMotionInterfaceIssueFault_Dec.__bases__: - bases = list(ns0.VMotionInterfaceIssueFault_Dec.__bases__) - bases.insert(0, ns0.VMotionInterfaceIssue_Def) - ns0.VMotionInterfaceIssueFault_Dec.__bases__ = tuple(bases) - - ns0.VMotionInterfaceIssue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMotionInterfaceIssueFault_Dec_Holder" - - class VMotionLinkCapacityLowFault_Dec(ElementDeclaration): - literal = "VMotionLinkCapacityLowFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMotionLinkCapacityLowFault") - kw["aname"] = "_VMotionLinkCapacityLowFault" - if ns0.VMotionLinkCapacityLow_Def not in ns0.VMotionLinkCapacityLowFault_Dec.__bases__: - bases = list(ns0.VMotionLinkCapacityLowFault_Dec.__bases__) - bases.insert(0, ns0.VMotionLinkCapacityLow_Def) - ns0.VMotionLinkCapacityLowFault_Dec.__bases__ = tuple(bases) - - ns0.VMotionLinkCapacityLow_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMotionLinkCapacityLowFault_Dec_Holder" - - class VMotionLinkDownFault_Dec(ElementDeclaration): - literal = "VMotionLinkDownFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMotionLinkDownFault") - kw["aname"] = "_VMotionLinkDownFault" - if ns0.VMotionLinkDown_Def not in ns0.VMotionLinkDownFault_Dec.__bases__: - bases = list(ns0.VMotionLinkDownFault_Dec.__bases__) - bases.insert(0, ns0.VMotionLinkDown_Def) - ns0.VMotionLinkDownFault_Dec.__bases__ = tuple(bases) - - ns0.VMotionLinkDown_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMotionLinkDownFault_Dec_Holder" - - class VMotionNotConfiguredFault_Dec(ElementDeclaration): - literal = "VMotionNotConfiguredFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMotionNotConfiguredFault") - kw["aname"] = "_VMotionNotConfiguredFault" - if ns0.VMotionNotConfigured_Def not in ns0.VMotionNotConfiguredFault_Dec.__bases__: - bases = list(ns0.VMotionNotConfiguredFault_Dec.__bases__) - bases.insert(0, ns0.VMotionNotConfigured_Def) - ns0.VMotionNotConfiguredFault_Dec.__bases__ = tuple(bases) - - ns0.VMotionNotConfigured_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMotionNotConfiguredFault_Dec_Holder" - - class VMotionNotLicensedFault_Dec(ElementDeclaration): - literal = "VMotionNotLicensedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMotionNotLicensedFault") - kw["aname"] = "_VMotionNotLicensedFault" - if ns0.VMotionNotLicensed_Def not in ns0.VMotionNotLicensedFault_Dec.__bases__: - bases = list(ns0.VMotionNotLicensedFault_Dec.__bases__) - bases.insert(0, ns0.VMotionNotLicensed_Def) - ns0.VMotionNotLicensedFault_Dec.__bases__ = tuple(bases) - - ns0.VMotionNotLicensed_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMotionNotLicensedFault_Dec_Holder" - - class VMotionNotSupportedFault_Dec(ElementDeclaration): - literal = "VMotionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMotionNotSupportedFault") - kw["aname"] = "_VMotionNotSupportedFault" - if ns0.VMotionNotSupported_Def not in ns0.VMotionNotSupportedFault_Dec.__bases__: - bases = list(ns0.VMotionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.VMotionNotSupported_Def) - ns0.VMotionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.VMotionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMotionNotSupportedFault_Dec_Holder" - - class VMotionProtocolIncompatibleFault_Dec(ElementDeclaration): - literal = "VMotionProtocolIncompatibleFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VMotionProtocolIncompatibleFault") - kw["aname"] = "_VMotionProtocolIncompatibleFault" - if ns0.VMotionProtocolIncompatible_Def not in ns0.VMotionProtocolIncompatibleFault_Dec.__bases__: - bases = list(ns0.VMotionProtocolIncompatibleFault_Dec.__bases__) - bases.insert(0, ns0.VMotionProtocolIncompatible_Def) - ns0.VMotionProtocolIncompatibleFault_Dec.__bases__ = tuple(bases) - - ns0.VMotionProtocolIncompatible_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VMotionProtocolIncompatibleFault_Dec_Holder" - - class VimFaultFault_Dec(ElementDeclaration): - literal = "VimFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VimFaultFault") - kw["aname"] = "_VimFaultFault" - if ns0.VimFault_Def not in ns0.VimFaultFault_Dec.__bases__: - bases = list(ns0.VimFaultFault_Dec.__bases__) - bases.insert(0, ns0.VimFault_Def) - ns0.VimFaultFault_Dec.__bases__ = tuple(bases) - - ns0.VimFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VimFaultFault_Dec_Holder" - - class VirtualDiskBlocksNotFullyProvisionedFault_Dec(ElementDeclaration): - literal = "VirtualDiskBlocksNotFullyProvisionedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VirtualDiskBlocksNotFullyProvisionedFault") - kw["aname"] = "_VirtualDiskBlocksNotFullyProvisionedFault" - if ns0.VirtualDiskBlocksNotFullyProvisioned_Def not in ns0.VirtualDiskBlocksNotFullyProvisionedFault_Dec.__bases__: - bases = list(ns0.VirtualDiskBlocksNotFullyProvisionedFault_Dec.__bases__) - bases.insert(0, ns0.VirtualDiskBlocksNotFullyProvisioned_Def) - ns0.VirtualDiskBlocksNotFullyProvisionedFault_Dec.__bases__ = tuple(bases) - - ns0.VirtualDiskBlocksNotFullyProvisioned_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VirtualDiskBlocksNotFullyProvisionedFault_Dec_Holder" - - class VirtualEthernetCardNotSupportedFault_Dec(ElementDeclaration): - literal = "VirtualEthernetCardNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VirtualEthernetCardNotSupportedFault") - kw["aname"] = "_VirtualEthernetCardNotSupportedFault" - if ns0.VirtualEthernetCardNotSupported_Def not in ns0.VirtualEthernetCardNotSupportedFault_Dec.__bases__: - bases = list(ns0.VirtualEthernetCardNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.VirtualEthernetCardNotSupported_Def) - ns0.VirtualEthernetCardNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.VirtualEthernetCardNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VirtualEthernetCardNotSupportedFault_Dec_Holder" - - class VirtualHardwareCompatibilityIssueFault_Dec(ElementDeclaration): - literal = "VirtualHardwareCompatibilityIssueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VirtualHardwareCompatibilityIssueFault") - kw["aname"] = "_VirtualHardwareCompatibilityIssueFault" - if ns0.VirtualHardwareCompatibilityIssue_Def not in ns0.VirtualHardwareCompatibilityIssueFault_Dec.__bases__: - bases = list(ns0.VirtualHardwareCompatibilityIssueFault_Dec.__bases__) - bases.insert(0, ns0.VirtualHardwareCompatibilityIssue_Def) - ns0.VirtualHardwareCompatibilityIssueFault_Dec.__bases__ = tuple(bases) - - ns0.VirtualHardwareCompatibilityIssue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VirtualHardwareCompatibilityIssueFault_Dec_Holder" - - class VirtualHardwareVersionNotSupportedFault_Dec(ElementDeclaration): - literal = "VirtualHardwareVersionNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VirtualHardwareVersionNotSupportedFault") - kw["aname"] = "_VirtualHardwareVersionNotSupportedFault" - if ns0.VirtualHardwareVersionNotSupported_Def not in ns0.VirtualHardwareVersionNotSupportedFault_Dec.__bases__: - bases = list(ns0.VirtualHardwareVersionNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.VirtualHardwareVersionNotSupported_Def) - ns0.VirtualHardwareVersionNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.VirtualHardwareVersionNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VirtualHardwareVersionNotSupportedFault_Dec_Holder" - - class VmAlreadyExistsInDatacenterFault_Dec(ElementDeclaration): - literal = "VmAlreadyExistsInDatacenterFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmAlreadyExistsInDatacenterFault") - kw["aname"] = "_VmAlreadyExistsInDatacenterFault" - if ns0.VmAlreadyExistsInDatacenter_Def not in ns0.VmAlreadyExistsInDatacenterFault_Dec.__bases__: - bases = list(ns0.VmAlreadyExistsInDatacenterFault_Dec.__bases__) - bases.insert(0, ns0.VmAlreadyExistsInDatacenter_Def) - ns0.VmAlreadyExistsInDatacenterFault_Dec.__bases__ = tuple(bases) - - ns0.VmAlreadyExistsInDatacenter_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmAlreadyExistsInDatacenterFault_Dec_Holder" - - class VmConfigFaultFault_Dec(ElementDeclaration): - literal = "VmConfigFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmConfigFaultFault") - kw["aname"] = "_VmConfigFaultFault" - if ns0.VmConfigFault_Def not in ns0.VmConfigFaultFault_Dec.__bases__: - bases = list(ns0.VmConfigFaultFault_Dec.__bases__) - bases.insert(0, ns0.VmConfigFault_Def) - ns0.VmConfigFaultFault_Dec.__bases__ = tuple(bases) - - ns0.VmConfigFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmConfigFaultFault_Dec_Holder" - - class VmConfigIncompatibleForFaultToleranceFault_Dec(ElementDeclaration): - literal = "VmConfigIncompatibleForFaultToleranceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmConfigIncompatibleForFaultToleranceFault") - kw["aname"] = "_VmConfigIncompatibleForFaultToleranceFault" - if ns0.VmConfigIncompatibleForFaultTolerance_Def not in ns0.VmConfigIncompatibleForFaultToleranceFault_Dec.__bases__: - bases = list(ns0.VmConfigIncompatibleForFaultToleranceFault_Dec.__bases__) - bases.insert(0, ns0.VmConfigIncompatibleForFaultTolerance_Def) - ns0.VmConfigIncompatibleForFaultToleranceFault_Dec.__bases__ = tuple(bases) - - ns0.VmConfigIncompatibleForFaultTolerance_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmConfigIncompatibleForFaultToleranceFault_Dec_Holder" - - class VmConfigIncompatibleForRecordReplayFault_Dec(ElementDeclaration): - literal = "VmConfigIncompatibleForRecordReplayFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmConfigIncompatibleForRecordReplayFault") - kw["aname"] = "_VmConfigIncompatibleForRecordReplayFault" - if ns0.VmConfigIncompatibleForRecordReplay_Def not in ns0.VmConfigIncompatibleForRecordReplayFault_Dec.__bases__: - bases = list(ns0.VmConfigIncompatibleForRecordReplayFault_Dec.__bases__) - bases.insert(0, ns0.VmConfigIncompatibleForRecordReplay_Def) - ns0.VmConfigIncompatibleForRecordReplayFault_Dec.__bases__ = tuple(bases) - - ns0.VmConfigIncompatibleForRecordReplay_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmConfigIncompatibleForRecordReplayFault_Dec_Holder" - - class VmFaultToleranceConfigIssueFault_Dec(ElementDeclaration): - literal = "VmFaultToleranceConfigIssueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmFaultToleranceConfigIssueFault") - kw["aname"] = "_VmFaultToleranceConfigIssueFault" - if ns0.VmFaultToleranceConfigIssue_Def not in ns0.VmFaultToleranceConfigIssueFault_Dec.__bases__: - bases = list(ns0.VmFaultToleranceConfigIssueFault_Dec.__bases__) - bases.insert(0, ns0.VmFaultToleranceConfigIssue_Def) - ns0.VmFaultToleranceConfigIssueFault_Dec.__bases__ = tuple(bases) - - ns0.VmFaultToleranceConfigIssue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceConfigIssueFault_Dec_Holder" - - class VmFaultToleranceInvalidFileBackingFault_Dec(ElementDeclaration): - literal = "VmFaultToleranceInvalidFileBackingFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmFaultToleranceInvalidFileBackingFault") - kw["aname"] = "_VmFaultToleranceInvalidFileBackingFault" - if ns0.VmFaultToleranceInvalidFileBacking_Def not in ns0.VmFaultToleranceInvalidFileBackingFault_Dec.__bases__: - bases = list(ns0.VmFaultToleranceInvalidFileBackingFault_Dec.__bases__) - bases.insert(0, ns0.VmFaultToleranceInvalidFileBacking_Def) - ns0.VmFaultToleranceInvalidFileBackingFault_Dec.__bases__ = tuple(bases) - - ns0.VmFaultToleranceInvalidFileBacking_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceInvalidFileBackingFault_Dec_Holder" - - class VmFaultToleranceIssueFault_Dec(ElementDeclaration): - literal = "VmFaultToleranceIssueFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmFaultToleranceIssueFault") - kw["aname"] = "_VmFaultToleranceIssueFault" - if ns0.VmFaultToleranceIssue_Def not in ns0.VmFaultToleranceIssueFault_Dec.__bases__: - bases = list(ns0.VmFaultToleranceIssueFault_Dec.__bases__) - bases.insert(0, ns0.VmFaultToleranceIssue_Def) - ns0.VmFaultToleranceIssueFault_Dec.__bases__ = tuple(bases) - - ns0.VmFaultToleranceIssue_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceIssueFault_Dec_Holder" - - class VmFaultToleranceOpIssuesListFault_Dec(ElementDeclaration): - literal = "VmFaultToleranceOpIssuesListFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmFaultToleranceOpIssuesListFault") - kw["aname"] = "_VmFaultToleranceOpIssuesListFault" - if ns0.VmFaultToleranceOpIssuesList_Def not in ns0.VmFaultToleranceOpIssuesListFault_Dec.__bases__: - bases = list(ns0.VmFaultToleranceOpIssuesListFault_Dec.__bases__) - bases.insert(0, ns0.VmFaultToleranceOpIssuesList_Def) - ns0.VmFaultToleranceOpIssuesListFault_Dec.__bases__ = tuple(bases) - - ns0.VmFaultToleranceOpIssuesList_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmFaultToleranceOpIssuesListFault_Dec_Holder" - - class VmLimitLicenseFault_Dec(ElementDeclaration): - literal = "VmLimitLicenseFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmLimitLicenseFault") - kw["aname"] = "_VmLimitLicenseFault" - if ns0.VmLimitLicense_Def not in ns0.VmLimitLicenseFault_Dec.__bases__: - bases = list(ns0.VmLimitLicenseFault_Dec.__bases__) - bases.insert(0, ns0.VmLimitLicense_Def) - ns0.VmLimitLicenseFault_Dec.__bases__ = tuple(bases) - - ns0.VmLimitLicense_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmLimitLicenseFault_Dec_Holder" - - class VmPowerOnDisabledFault_Dec(ElementDeclaration): - literal = "VmPowerOnDisabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmPowerOnDisabledFault") - kw["aname"] = "_VmPowerOnDisabledFault" - if ns0.VmPowerOnDisabled_Def not in ns0.VmPowerOnDisabledFault_Dec.__bases__: - bases = list(ns0.VmPowerOnDisabledFault_Dec.__bases__) - bases.insert(0, ns0.VmPowerOnDisabled_Def) - ns0.VmPowerOnDisabledFault_Dec.__bases__ = tuple(bases) - - ns0.VmPowerOnDisabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmPowerOnDisabledFault_Dec_Holder" - - class VmToolsUpgradeFaultFault_Dec(ElementDeclaration): - literal = "VmToolsUpgradeFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmToolsUpgradeFaultFault") - kw["aname"] = "_VmToolsUpgradeFaultFault" - if ns0.VmToolsUpgradeFault_Def not in ns0.VmToolsUpgradeFaultFault_Dec.__bases__: - bases = list(ns0.VmToolsUpgradeFaultFault_Dec.__bases__) - bases.insert(0, ns0.VmToolsUpgradeFault_Def) - ns0.VmToolsUpgradeFaultFault_Dec.__bases__ = tuple(bases) - - ns0.VmToolsUpgradeFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmToolsUpgradeFaultFault_Dec_Holder" - - class VmValidateMaxDeviceFault_Dec(ElementDeclaration): - literal = "VmValidateMaxDeviceFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmValidateMaxDeviceFault") - kw["aname"] = "_VmValidateMaxDeviceFault" - if ns0.VmValidateMaxDevice_Def not in ns0.VmValidateMaxDeviceFault_Dec.__bases__: - bases = list(ns0.VmValidateMaxDeviceFault_Dec.__bases__) - bases.insert(0, ns0.VmValidateMaxDevice_Def) - ns0.VmValidateMaxDeviceFault_Dec.__bases__ = tuple(bases) - - ns0.VmValidateMaxDevice_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmValidateMaxDeviceFault_Dec_Holder" - - class VmWwnConflictFault_Dec(ElementDeclaration): - literal = "VmWwnConflictFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmWwnConflictFault") - kw["aname"] = "_VmWwnConflictFault" - if ns0.VmWwnConflict_Def not in ns0.VmWwnConflictFault_Dec.__bases__: - bases = list(ns0.VmWwnConflictFault_Dec.__bases__) - bases.insert(0, ns0.VmWwnConflict_Def) - ns0.VmWwnConflictFault_Dec.__bases__ = tuple(bases) - - ns0.VmWwnConflict_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmWwnConflictFault_Dec_Holder" - - class VmfsAlreadyMountedFault_Dec(ElementDeclaration): - literal = "VmfsAlreadyMountedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmfsAlreadyMountedFault") - kw["aname"] = "_VmfsAlreadyMountedFault" - if ns0.VmfsAlreadyMounted_Def not in ns0.VmfsAlreadyMountedFault_Dec.__bases__: - bases = list(ns0.VmfsAlreadyMountedFault_Dec.__bases__) - bases.insert(0, ns0.VmfsAlreadyMounted_Def) - ns0.VmfsAlreadyMountedFault_Dec.__bases__ = tuple(bases) - - ns0.VmfsAlreadyMounted_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmfsAlreadyMountedFault_Dec_Holder" - - class VmfsAmbiguousMountFault_Dec(ElementDeclaration): - literal = "VmfsAmbiguousMountFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmfsAmbiguousMountFault") - kw["aname"] = "_VmfsAmbiguousMountFault" - if ns0.VmfsAmbiguousMount_Def not in ns0.VmfsAmbiguousMountFault_Dec.__bases__: - bases = list(ns0.VmfsAmbiguousMountFault_Dec.__bases__) - bases.insert(0, ns0.VmfsAmbiguousMount_Def) - ns0.VmfsAmbiguousMountFault_Dec.__bases__ = tuple(bases) - - ns0.VmfsAmbiguousMount_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmfsAmbiguousMountFault_Dec_Holder" - - class VmfsMountFaultFault_Dec(ElementDeclaration): - literal = "VmfsMountFaultFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmfsMountFaultFault") - kw["aname"] = "_VmfsMountFaultFault" - if ns0.VmfsMountFault_Def not in ns0.VmfsMountFaultFault_Dec.__bases__: - bases = list(ns0.VmfsMountFaultFault_Dec.__bases__) - bases.insert(0, ns0.VmfsMountFault_Def) - ns0.VmfsMountFaultFault_Dec.__bases__ = tuple(bases) - - ns0.VmfsMountFault_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmfsMountFaultFault_Dec_Holder" - - class VmotionInterfaceNotEnabledFault_Dec(ElementDeclaration): - literal = "VmotionInterfaceNotEnabledFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VmotionInterfaceNotEnabledFault") - kw["aname"] = "_VmotionInterfaceNotEnabledFault" - if ns0.VmotionInterfaceNotEnabled_Def not in ns0.VmotionInterfaceNotEnabledFault_Dec.__bases__: - bases = list(ns0.VmotionInterfaceNotEnabledFault_Dec.__bases__) - bases.insert(0, ns0.VmotionInterfaceNotEnabled_Def) - ns0.VmotionInterfaceNotEnabledFault_Dec.__bases__ = tuple(bases) - - ns0.VmotionInterfaceNotEnabled_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VmotionInterfaceNotEnabledFault_Dec_Holder" - - class VolumeEditorErrorFault_Dec(ElementDeclaration): - literal = "VolumeEditorErrorFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VolumeEditorErrorFault") - kw["aname"] = "_VolumeEditorErrorFault" - if ns0.VolumeEditorError_Def not in ns0.VolumeEditorErrorFault_Dec.__bases__: - bases = list(ns0.VolumeEditorErrorFault_Dec.__bases__) - bases.insert(0, ns0.VolumeEditorError_Def) - ns0.VolumeEditorErrorFault_Dec.__bases__ = tuple(bases) - - ns0.VolumeEditorError_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VolumeEditorErrorFault_Dec_Holder" - - class WakeOnLanNotSupportedFault_Dec(ElementDeclaration): - literal = "WakeOnLanNotSupportedFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","WakeOnLanNotSupportedFault") - kw["aname"] = "_WakeOnLanNotSupportedFault" - if ns0.WakeOnLanNotSupported_Def not in ns0.WakeOnLanNotSupportedFault_Dec.__bases__: - bases = list(ns0.WakeOnLanNotSupportedFault_Dec.__bases__) - bases.insert(0, ns0.WakeOnLanNotSupported_Def) - ns0.WakeOnLanNotSupportedFault_Dec.__bases__ = tuple(bases) - - ns0.WakeOnLanNotSupported_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "WakeOnLanNotSupportedFault_Dec_Holder" - - class WakeOnLanNotSupportedByVmotionNICFault_Dec(ElementDeclaration): - literal = "WakeOnLanNotSupportedByVmotionNICFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","WakeOnLanNotSupportedByVmotionNICFault") - kw["aname"] = "_WakeOnLanNotSupportedByVmotionNICFault" - if ns0.WakeOnLanNotSupportedByVmotionNIC_Def not in ns0.WakeOnLanNotSupportedByVmotionNICFault_Dec.__bases__: - bases = list(ns0.WakeOnLanNotSupportedByVmotionNICFault_Dec.__bases__) - bases.insert(0, ns0.WakeOnLanNotSupportedByVmotionNIC_Def) - ns0.WakeOnLanNotSupportedByVmotionNICFault_Dec.__bases__ = tuple(bases) - - ns0.WakeOnLanNotSupportedByVmotionNIC_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "WakeOnLanNotSupportedByVmotionNICFault_Dec_Holder" - - class WillModifyConfigCpuRequirementsFault_Dec(ElementDeclaration): - literal = "WillModifyConfigCpuRequirementsFault" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","WillModifyConfigCpuRequirementsFault") - kw["aname"] = "_WillModifyConfigCpuRequirementsFault" - if ns0.WillModifyConfigCpuRequirements_Def not in ns0.WillModifyConfigCpuRequirementsFault_Dec.__bases__: - bases = list(ns0.WillModifyConfigCpuRequirementsFault_Dec.__bases__) - bases.insert(0, ns0.WillModifyConfigCpuRequirements_Def) - ns0.WillModifyConfigCpuRequirementsFault_Dec.__bases__ = tuple(bases) - - ns0.WillModifyConfigCpuRequirements_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "WillModifyConfigCpuRequirementsFault_Dec_Holder" - - class ReconfigureAutostart_Dec(ElementDeclaration): - literal = "ReconfigureAutostart" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureAutostart") - kw["aname"] = "_ReconfigureAutostart" - if ns0.ReconfigureAutostartRequestType_Def not in ns0.ReconfigureAutostart_Dec.__bases__: - bases = list(ns0.ReconfigureAutostart_Dec.__bases__) - bases.insert(0, ns0.ReconfigureAutostartRequestType_Def) - ns0.ReconfigureAutostart_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureAutostartRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureAutostart_Dec_Holder" - - class ReconfigureAutostartResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureAutostartResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureAutostartResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureAutostartResponse") - kw["aname"] = "_ReconfigureAutostartResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureAutostartResponse_Holder" - self.pyclass = Holder - - class AutoStartPowerOn_Dec(ElementDeclaration): - literal = "AutoStartPowerOn" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AutoStartPowerOn") - kw["aname"] = "_AutoStartPowerOn" - if ns0.AutoStartPowerOnRequestType_Def not in ns0.AutoStartPowerOn_Dec.__bases__: - bases = list(ns0.AutoStartPowerOn_Dec.__bases__) - bases.insert(0, ns0.AutoStartPowerOnRequestType_Def) - ns0.AutoStartPowerOn_Dec.__bases__ = tuple(bases) - - ns0.AutoStartPowerOnRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AutoStartPowerOn_Dec_Holder" - - class AutoStartPowerOnResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AutoStartPowerOnResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AutoStartPowerOnResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AutoStartPowerOnResponse") - kw["aname"] = "_AutoStartPowerOnResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AutoStartPowerOnResponse_Holder" - self.pyclass = Holder - - class AutoStartPowerOff_Dec(ElementDeclaration): - literal = "AutoStartPowerOff" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AutoStartPowerOff") - kw["aname"] = "_AutoStartPowerOff" - if ns0.AutoStartPowerOffRequestType_Def not in ns0.AutoStartPowerOff_Dec.__bases__: - bases = list(ns0.AutoStartPowerOff_Dec.__bases__) - bases.insert(0, ns0.AutoStartPowerOffRequestType_Def) - ns0.AutoStartPowerOff_Dec.__bases__ = tuple(bases) - - ns0.AutoStartPowerOffRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AutoStartPowerOff_Dec_Holder" - - class AutoStartPowerOffResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AutoStartPowerOffResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AutoStartPowerOffResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AutoStartPowerOffResponse") - kw["aname"] = "_AutoStartPowerOffResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AutoStartPowerOffResponse_Holder" - self.pyclass = Holder - - class QueryBootDevices_Dec(ElementDeclaration): - literal = "QueryBootDevices" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryBootDevices") - kw["aname"] = "_QueryBootDevices" - if ns0.QueryBootDevicesRequestType_Def not in ns0.QueryBootDevices_Dec.__bases__: - bases = list(ns0.QueryBootDevices_Dec.__bases__) - bases.insert(0, ns0.QueryBootDevicesRequestType_Def) - ns0.QueryBootDevices_Dec.__bases__ = tuple(bases) - - ns0.QueryBootDevicesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryBootDevices_Dec_Holder" - - class QueryBootDevicesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryBootDevicesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryBootDevicesResponse_Dec.schema - TClist = [GTD("urn:vim25","HostBootDeviceInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryBootDevicesResponse") - kw["aname"] = "_QueryBootDevicesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryBootDevicesResponse_Holder" - self.pyclass = Holder - - class UpdateBootDevice_Dec(ElementDeclaration): - literal = "UpdateBootDevice" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateBootDevice") - kw["aname"] = "_UpdateBootDevice" - if ns0.UpdateBootDeviceRequestType_Def not in ns0.UpdateBootDevice_Dec.__bases__: - bases = list(ns0.UpdateBootDevice_Dec.__bases__) - bases.insert(0, ns0.UpdateBootDeviceRequestType_Def) - ns0.UpdateBootDevice_Dec.__bases__ = tuple(bases) - - ns0.UpdateBootDeviceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateBootDevice_Dec_Holder" - - class UpdateBootDeviceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateBootDeviceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateBootDeviceResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateBootDeviceResponse") - kw["aname"] = "_UpdateBootDeviceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateBootDeviceResponse_Holder" - self.pyclass = Holder - - class EnableHyperThreading_Dec(ElementDeclaration): - literal = "EnableHyperThreading" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnableHyperThreading") - kw["aname"] = "_EnableHyperThreading" - if ns0.EnableHyperThreadingRequestType_Def not in ns0.EnableHyperThreading_Dec.__bases__: - bases = list(ns0.EnableHyperThreading_Dec.__bases__) - bases.insert(0, ns0.EnableHyperThreadingRequestType_Def) - ns0.EnableHyperThreading_Dec.__bases__ = tuple(bases) - - ns0.EnableHyperThreadingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnableHyperThreading_Dec_Holder" - - class EnableHyperThreadingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnableHyperThreadingResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnableHyperThreadingResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","EnableHyperThreadingResponse") - kw["aname"] = "_EnableHyperThreadingResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "EnableHyperThreadingResponse_Holder" - self.pyclass = Holder - - class DisableHyperThreading_Dec(ElementDeclaration): - literal = "DisableHyperThreading" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisableHyperThreading") - kw["aname"] = "_DisableHyperThreading" - if ns0.DisableHyperThreadingRequestType_Def not in ns0.DisableHyperThreading_Dec.__bases__: - bases = list(ns0.DisableHyperThreading_Dec.__bases__) - bases.insert(0, ns0.DisableHyperThreadingRequestType_Def) - ns0.DisableHyperThreading_Dec.__bases__ = tuple(bases) - - ns0.DisableHyperThreadingRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisableHyperThreading_Dec_Holder" - - class DisableHyperThreadingResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisableHyperThreadingResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisableHyperThreadingResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DisableHyperThreadingResponse") - kw["aname"] = "_DisableHyperThreadingResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DisableHyperThreadingResponse_Holder" - self.pyclass = Holder - - class SearchDatastore_Dec(ElementDeclaration): - literal = "SearchDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SearchDatastore") - kw["aname"] = "_SearchDatastore" - if ns0.SearchDatastoreRequestType_Def not in ns0.SearchDatastore_Dec.__bases__: - bases = list(ns0.SearchDatastore_Dec.__bases__) - bases.insert(0, ns0.SearchDatastoreRequestType_Def) - ns0.SearchDatastore_Dec.__bases__ = tuple(bases) - - ns0.SearchDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastore_Dec_Holder" - - class SearchDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SearchDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SearchDatastoreResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDatastoreBrowserSearchResults",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","SearchDatastoreResponse") - kw["aname"] = "_SearchDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "SearchDatastoreResponse_Holder" - self.pyclass = Holder - - class SearchDatastore_Task_Dec(ElementDeclaration): - literal = "SearchDatastore_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SearchDatastore_Task") - kw["aname"] = "_SearchDatastore_Task" - if ns0.SearchDatastoreRequestType_Def not in ns0.SearchDatastore_Task_Dec.__bases__: - bases = list(ns0.SearchDatastore_Task_Dec.__bases__) - bases.insert(0, ns0.SearchDatastoreRequestType_Def) - ns0.SearchDatastore_Task_Dec.__bases__ = tuple(bases) - - ns0.SearchDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastore_Task_Dec_Holder" - - class SearchDatastore_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SearchDatastore_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SearchDatastore_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","SearchDatastore_TaskResponse") - kw["aname"] = "_SearchDatastore_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "SearchDatastore_TaskResponse_Holder" - self.pyclass = Holder - - class SearchDatastoreSubFolders_Dec(ElementDeclaration): - literal = "SearchDatastoreSubFolders" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SearchDatastoreSubFolders") - kw["aname"] = "_SearchDatastoreSubFolders" - if ns0.SearchDatastoreSubFoldersRequestType_Def not in ns0.SearchDatastoreSubFolders_Dec.__bases__: - bases = list(ns0.SearchDatastoreSubFolders_Dec.__bases__) - bases.insert(0, ns0.SearchDatastoreSubFoldersRequestType_Def) - ns0.SearchDatastoreSubFolders_Dec.__bases__ = tuple(bases) - - ns0.SearchDatastoreSubFoldersRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastoreSubFolders_Dec_Holder" - - class SearchDatastoreSubFoldersResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SearchDatastoreSubFoldersResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SearchDatastoreSubFoldersResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDatastoreBrowserSearchResults",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","SearchDatastoreSubFoldersResponse") - kw["aname"] = "_SearchDatastoreSubFoldersResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "SearchDatastoreSubFoldersResponse_Holder" - self.pyclass = Holder - - class SearchDatastoreSubFolders_Task_Dec(ElementDeclaration): - literal = "SearchDatastoreSubFolders_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SearchDatastoreSubFolders_Task") - kw["aname"] = "_SearchDatastoreSubFolders_Task" - if ns0.SearchDatastoreSubFoldersRequestType_Def not in ns0.SearchDatastoreSubFolders_Task_Dec.__bases__: - bases = list(ns0.SearchDatastoreSubFolders_Task_Dec.__bases__) - bases.insert(0, ns0.SearchDatastoreSubFoldersRequestType_Def) - ns0.SearchDatastoreSubFolders_Task_Dec.__bases__ = tuple(bases) - - ns0.SearchDatastoreSubFoldersRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SearchDatastoreSubFolders_Task_Dec_Holder" - - class SearchDatastoreSubFolders_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SearchDatastoreSubFolders_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SearchDatastoreSubFolders_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","SearchDatastoreSubFolders_TaskResponse") - kw["aname"] = "_SearchDatastoreSubFolders_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "SearchDatastoreSubFolders_TaskResponse_Holder" - self.pyclass = Holder - - class DeleteFile_Dec(ElementDeclaration): - literal = "DeleteFile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeleteFile") - kw["aname"] = "_DeleteFile" - if ns0.DeleteFileRequestType_Def not in ns0.DeleteFile_Dec.__bases__: - bases = list(ns0.DeleteFile_Dec.__bases__) - bases.insert(0, ns0.DeleteFileRequestType_Def) - ns0.DeleteFile_Dec.__bases__ = tuple(bases) - - ns0.DeleteFileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeleteFile_Dec_Holder" - - class DeleteFileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DeleteFileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DeleteFileResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DeleteFileResponse") - kw["aname"] = "_DeleteFileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DeleteFileResponse_Holder" - self.pyclass = Holder - - class UpdateLocalSwapDatastore_Dec(ElementDeclaration): - literal = "UpdateLocalSwapDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateLocalSwapDatastore") - kw["aname"] = "_UpdateLocalSwapDatastore" - if ns0.UpdateLocalSwapDatastoreRequestType_Def not in ns0.UpdateLocalSwapDatastore_Dec.__bases__: - bases = list(ns0.UpdateLocalSwapDatastore_Dec.__bases__) - bases.insert(0, ns0.UpdateLocalSwapDatastoreRequestType_Def) - ns0.UpdateLocalSwapDatastore_Dec.__bases__ = tuple(bases) - - ns0.UpdateLocalSwapDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateLocalSwapDatastore_Dec_Holder" - - class UpdateLocalSwapDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateLocalSwapDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateLocalSwapDatastoreResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateLocalSwapDatastoreResponse") - kw["aname"] = "_UpdateLocalSwapDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateLocalSwapDatastoreResponse_Holder" - self.pyclass = Holder - - class QueryAvailableDisksForVmfs_Dec(ElementDeclaration): - literal = "QueryAvailableDisksForVmfs" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryAvailableDisksForVmfs") - kw["aname"] = "_QueryAvailableDisksForVmfs" - if ns0.QueryAvailableDisksForVmfsRequestType_Def not in ns0.QueryAvailableDisksForVmfs_Dec.__bases__: - bases = list(ns0.QueryAvailableDisksForVmfs_Dec.__bases__) - bases.insert(0, ns0.QueryAvailableDisksForVmfsRequestType_Def) - ns0.QueryAvailableDisksForVmfs_Dec.__bases__ = tuple(bases) - - ns0.QueryAvailableDisksForVmfsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailableDisksForVmfs_Dec_Holder" - - class QueryAvailableDisksForVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryAvailableDisksForVmfsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryAvailableDisksForVmfsResponse_Dec.schema - TClist = [GTD("urn:vim25","HostScsiDisk",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryAvailableDisksForVmfsResponse") - kw["aname"] = "_QueryAvailableDisksForVmfsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryAvailableDisksForVmfsResponse_Holder" - self.pyclass = Holder - - class QueryVmfsDatastoreCreateOptions_Dec(ElementDeclaration): - literal = "QueryVmfsDatastoreCreateOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVmfsDatastoreCreateOptions") - kw["aname"] = "_QueryVmfsDatastoreCreateOptions" - if ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def not in ns0.QueryVmfsDatastoreCreateOptions_Dec.__bases__: - bases = list(ns0.QueryVmfsDatastoreCreateOptions_Dec.__bases__) - bases.insert(0, ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def) - ns0.QueryVmfsDatastoreCreateOptions_Dec.__bases__ = tuple(bases) - - ns0.QueryVmfsDatastoreCreateOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVmfsDatastoreCreateOptions_Dec_Holder" - - class QueryVmfsDatastoreCreateOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVmfsDatastoreCreateOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVmfsDatastoreCreateOptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVmfsDatastoreCreateOptionsResponse") - kw["aname"] = "_QueryVmfsDatastoreCreateOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryVmfsDatastoreCreateOptionsResponse_Holder" - self.pyclass = Holder - - class CreateVmfsDatastore_Dec(ElementDeclaration): - literal = "CreateVmfsDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateVmfsDatastore") - kw["aname"] = "_CreateVmfsDatastore" - if ns0.CreateVmfsDatastoreRequestType_Def not in ns0.CreateVmfsDatastore_Dec.__bases__: - bases = list(ns0.CreateVmfsDatastore_Dec.__bases__) - bases.insert(0, ns0.CreateVmfsDatastoreRequestType_Def) - ns0.CreateVmfsDatastore_Dec.__bases__ = tuple(bases) - - ns0.CreateVmfsDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateVmfsDatastore_Dec_Holder" - - class CreateVmfsDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateVmfsDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateVmfsDatastoreResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateVmfsDatastoreResponse") - kw["aname"] = "_CreateVmfsDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateVmfsDatastoreResponse_Holder" - self.pyclass = Holder - - class QueryVmfsDatastoreExtendOptions_Dec(ElementDeclaration): - literal = "QueryVmfsDatastoreExtendOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExtendOptions") - kw["aname"] = "_QueryVmfsDatastoreExtendOptions" - if ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def not in ns0.QueryVmfsDatastoreExtendOptions_Dec.__bases__: - bases = list(ns0.QueryVmfsDatastoreExtendOptions_Dec.__bases__) - bases.insert(0, ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def) - ns0.QueryVmfsDatastoreExtendOptions_Dec.__bases__ = tuple(bases) - - ns0.QueryVmfsDatastoreExtendOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVmfsDatastoreExtendOptions_Dec_Holder" - - class QueryVmfsDatastoreExtendOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVmfsDatastoreExtendOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVmfsDatastoreExtendOptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExtendOptionsResponse") - kw["aname"] = "_QueryVmfsDatastoreExtendOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryVmfsDatastoreExtendOptionsResponse_Holder" - self.pyclass = Holder - - class QueryVmfsDatastoreExpandOptions_Dec(ElementDeclaration): - literal = "QueryVmfsDatastoreExpandOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExpandOptions") - kw["aname"] = "_QueryVmfsDatastoreExpandOptions" - if ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def not in ns0.QueryVmfsDatastoreExpandOptions_Dec.__bases__: - bases = list(ns0.QueryVmfsDatastoreExpandOptions_Dec.__bases__) - bases.insert(0, ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def) - ns0.QueryVmfsDatastoreExpandOptions_Dec.__bases__ = tuple(bases) - - ns0.QueryVmfsDatastoreExpandOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVmfsDatastoreExpandOptions_Dec_Holder" - - class QueryVmfsDatastoreExpandOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVmfsDatastoreExpandOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVmfsDatastoreExpandOptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","VmfsDatastoreOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVmfsDatastoreExpandOptionsResponse") - kw["aname"] = "_QueryVmfsDatastoreExpandOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryVmfsDatastoreExpandOptionsResponse_Holder" - self.pyclass = Holder - - class ExtendVmfsDatastore_Dec(ElementDeclaration): - literal = "ExtendVmfsDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExtendVmfsDatastore") - kw["aname"] = "_ExtendVmfsDatastore" - if ns0.ExtendVmfsDatastoreRequestType_Def not in ns0.ExtendVmfsDatastore_Dec.__bases__: - bases = list(ns0.ExtendVmfsDatastore_Dec.__bases__) - bases.insert(0, ns0.ExtendVmfsDatastoreRequestType_Def) - ns0.ExtendVmfsDatastore_Dec.__bases__ = tuple(bases) - - ns0.ExtendVmfsDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExtendVmfsDatastore_Dec_Holder" - - class ExtendVmfsDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExtendVmfsDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExtendVmfsDatastoreResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ExtendVmfsDatastoreResponse") - kw["aname"] = "_ExtendVmfsDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ExtendVmfsDatastoreResponse_Holder" - self.pyclass = Holder - - class ExpandVmfsDatastore_Dec(ElementDeclaration): - literal = "ExpandVmfsDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExpandVmfsDatastore") - kw["aname"] = "_ExpandVmfsDatastore" - if ns0.ExpandVmfsDatastoreRequestType_Def not in ns0.ExpandVmfsDatastore_Dec.__bases__: - bases = list(ns0.ExpandVmfsDatastore_Dec.__bases__) - bases.insert(0, ns0.ExpandVmfsDatastoreRequestType_Def) - ns0.ExpandVmfsDatastore_Dec.__bases__ = tuple(bases) - - ns0.ExpandVmfsDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExpandVmfsDatastore_Dec_Holder" - - class ExpandVmfsDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExpandVmfsDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExpandVmfsDatastoreResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ExpandVmfsDatastoreResponse") - kw["aname"] = "_ExpandVmfsDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ExpandVmfsDatastoreResponse_Holder" - self.pyclass = Holder - - class CreateNasDatastore_Dec(ElementDeclaration): - literal = "CreateNasDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateNasDatastore") - kw["aname"] = "_CreateNasDatastore" - if ns0.CreateNasDatastoreRequestType_Def not in ns0.CreateNasDatastore_Dec.__bases__: - bases = list(ns0.CreateNasDatastore_Dec.__bases__) - bases.insert(0, ns0.CreateNasDatastoreRequestType_Def) - ns0.CreateNasDatastore_Dec.__bases__ = tuple(bases) - - ns0.CreateNasDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateNasDatastore_Dec_Holder" - - class CreateNasDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateNasDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateNasDatastoreResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateNasDatastoreResponse") - kw["aname"] = "_CreateNasDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateNasDatastoreResponse_Holder" - self.pyclass = Holder - - class CreateLocalDatastore_Dec(ElementDeclaration): - literal = "CreateLocalDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateLocalDatastore") - kw["aname"] = "_CreateLocalDatastore" - if ns0.CreateLocalDatastoreRequestType_Def not in ns0.CreateLocalDatastore_Dec.__bases__: - bases = list(ns0.CreateLocalDatastore_Dec.__bases__) - bases.insert(0, ns0.CreateLocalDatastoreRequestType_Def) - ns0.CreateLocalDatastore_Dec.__bases__ = tuple(bases) - - ns0.CreateLocalDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateLocalDatastore_Dec_Holder" - - class CreateLocalDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateLocalDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateLocalDatastoreResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateLocalDatastoreResponse") - kw["aname"] = "_CreateLocalDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateLocalDatastoreResponse_Holder" - self.pyclass = Holder - - class RemoveDatastore_Dec(ElementDeclaration): - literal = "RemoveDatastore" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveDatastore") - kw["aname"] = "_RemoveDatastore" - if ns0.RemoveDatastoreRequestType_Def not in ns0.RemoveDatastore_Dec.__bases__: - bases = list(ns0.RemoveDatastore_Dec.__bases__) - bases.insert(0, ns0.RemoveDatastoreRequestType_Def) - ns0.RemoveDatastore_Dec.__bases__ = tuple(bases) - - ns0.RemoveDatastoreRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveDatastore_Dec_Holder" - - class RemoveDatastoreResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveDatastoreResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveDatastoreResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveDatastoreResponse") - kw["aname"] = "_RemoveDatastoreResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveDatastoreResponse_Holder" - self.pyclass = Holder - - class ConfigureDatastorePrincipal_Dec(ElementDeclaration): - literal = "ConfigureDatastorePrincipal" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ConfigureDatastorePrincipal") - kw["aname"] = "_ConfigureDatastorePrincipal" - if ns0.ConfigureDatastorePrincipalRequestType_Def not in ns0.ConfigureDatastorePrincipal_Dec.__bases__: - bases = list(ns0.ConfigureDatastorePrincipal_Dec.__bases__) - bases.insert(0, ns0.ConfigureDatastorePrincipalRequestType_Def) - ns0.ConfigureDatastorePrincipal_Dec.__bases__ = tuple(bases) - - ns0.ConfigureDatastorePrincipalRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ConfigureDatastorePrincipal_Dec_Holder" - - class ConfigureDatastorePrincipalResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ConfigureDatastorePrincipalResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ConfigureDatastorePrincipalResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ConfigureDatastorePrincipalResponse") - kw["aname"] = "_ConfigureDatastorePrincipalResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ConfigureDatastorePrincipalResponse_Holder" - self.pyclass = Holder - - class QueryUnresolvedVmfsVolumes_Dec(ElementDeclaration): - literal = "QueryUnresolvedVmfsVolumes" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolumes") - kw["aname"] = "_QueryUnresolvedVmfsVolumes" - if ns0.QueryUnresolvedVmfsVolumesRequestType_Def not in ns0.QueryUnresolvedVmfsVolumes_Dec.__bases__: - bases = list(ns0.QueryUnresolvedVmfsVolumes_Dec.__bases__) - bases.insert(0, ns0.QueryUnresolvedVmfsVolumesRequestType_Def) - ns0.QueryUnresolvedVmfsVolumes_Dec.__bases__ = tuple(bases) - - ns0.QueryUnresolvedVmfsVolumesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryUnresolvedVmfsVolumes_Dec_Holder" - - class QueryUnresolvedVmfsVolumesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryUnresolvedVmfsVolumesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryUnresolvedVmfsVolumesResponse_Dec.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsVolume",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolumesResponse") - kw["aname"] = "_QueryUnresolvedVmfsVolumesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryUnresolvedVmfsVolumesResponse_Holder" - self.pyclass = Holder - - class ResignatureUnresolvedVmfsVolume_Dec(ElementDeclaration): - literal = "ResignatureUnresolvedVmfsVolume" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolume") - kw["aname"] = "_ResignatureUnresolvedVmfsVolume" - if ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def not in ns0.ResignatureUnresolvedVmfsVolume_Dec.__bases__: - bases = list(ns0.ResignatureUnresolvedVmfsVolume_Dec.__bases__) - bases.insert(0, ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def) - ns0.ResignatureUnresolvedVmfsVolume_Dec.__bases__ = tuple(bases) - - ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResignatureUnresolvedVmfsVolume_Dec_Holder" - - class ResignatureUnresolvedVmfsVolumeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResignatureUnresolvedVmfsVolumeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResignatureUnresolvedVmfsVolumeResponse_Dec.schema - TClist = [GTD("urn:vim25","HostResignatureRescanResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolumeResponse") - kw["aname"] = "_ResignatureUnresolvedVmfsVolumeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ResignatureUnresolvedVmfsVolumeResponse_Holder" - self.pyclass = Holder - - class ResignatureUnresolvedVmfsVolume_Task_Dec(ElementDeclaration): - literal = "ResignatureUnresolvedVmfsVolume_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolume_Task") - kw["aname"] = "_ResignatureUnresolvedVmfsVolume_Task" - if ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def not in ns0.ResignatureUnresolvedVmfsVolume_Task_Dec.__bases__: - bases = list(ns0.ResignatureUnresolvedVmfsVolume_Task_Dec.__bases__) - bases.insert(0, ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def) - ns0.ResignatureUnresolvedVmfsVolume_Task_Dec.__bases__ = tuple(bases) - - ns0.ResignatureUnresolvedVmfsVolumeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResignatureUnresolvedVmfsVolume_Task_Dec_Holder" - - class ResignatureUnresolvedVmfsVolume_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResignatureUnresolvedVmfsVolume_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResignatureUnresolvedVmfsVolume_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ResignatureUnresolvedVmfsVolume_TaskResponse") - kw["aname"] = "_ResignatureUnresolvedVmfsVolume_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ResignatureUnresolvedVmfsVolume_TaskResponse_Holder" - self.pyclass = Holder - - class UpdateDateTimeConfig_Dec(ElementDeclaration): - literal = "UpdateDateTimeConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateDateTimeConfig") - kw["aname"] = "_UpdateDateTimeConfig" - if ns0.UpdateDateTimeConfigRequestType_Def not in ns0.UpdateDateTimeConfig_Dec.__bases__: - bases = list(ns0.UpdateDateTimeConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateDateTimeConfigRequestType_Def) - ns0.UpdateDateTimeConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateDateTimeConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateDateTimeConfig_Dec_Holder" - - class UpdateDateTimeConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateDateTimeConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateDateTimeConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateDateTimeConfigResponse") - kw["aname"] = "_UpdateDateTimeConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateDateTimeConfigResponse_Holder" - self.pyclass = Holder - - class QueryAvailableTimeZones_Dec(ElementDeclaration): - literal = "QueryAvailableTimeZones" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryAvailableTimeZones") - kw["aname"] = "_QueryAvailableTimeZones" - if ns0.QueryAvailableTimeZonesRequestType_Def not in ns0.QueryAvailableTimeZones_Dec.__bases__: - bases = list(ns0.QueryAvailableTimeZones_Dec.__bases__) - bases.insert(0, ns0.QueryAvailableTimeZonesRequestType_Def) - ns0.QueryAvailableTimeZones_Dec.__bases__ = tuple(bases) - - ns0.QueryAvailableTimeZonesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailableTimeZones_Dec_Holder" - - class QueryAvailableTimeZonesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryAvailableTimeZonesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryAvailableTimeZonesResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDateTimeSystemTimeZone",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryAvailableTimeZonesResponse") - kw["aname"] = "_QueryAvailableTimeZonesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryAvailableTimeZonesResponse_Holder" - self.pyclass = Holder - - class QueryDateTime_Dec(ElementDeclaration): - literal = "QueryDateTime" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryDateTime") - kw["aname"] = "_QueryDateTime" - if ns0.QueryDateTimeRequestType_Def not in ns0.QueryDateTime_Dec.__bases__: - bases = list(ns0.QueryDateTime_Dec.__bases__) - bases.insert(0, ns0.QueryDateTimeRequestType_Def) - ns0.QueryDateTime_Dec.__bases__ = tuple(bases) - - ns0.QueryDateTimeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryDateTime_Dec_Holder" - - class QueryDateTimeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryDateTimeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryDateTimeResponse_Dec.schema - TClist = [ZSI.TCtimes.gDateTime(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryDateTimeResponse") - kw["aname"] = "_QueryDateTimeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryDateTimeResponse_Holder" - self.pyclass = Holder - - class UpdateDateTime_Dec(ElementDeclaration): - literal = "UpdateDateTime" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateDateTime") - kw["aname"] = "_UpdateDateTime" - if ns0.UpdateDateTimeRequestType_Def not in ns0.UpdateDateTime_Dec.__bases__: - bases = list(ns0.UpdateDateTime_Dec.__bases__) - bases.insert(0, ns0.UpdateDateTimeRequestType_Def) - ns0.UpdateDateTime_Dec.__bases__ = tuple(bases) - - ns0.UpdateDateTimeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateDateTime_Dec_Holder" - - class UpdateDateTimeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateDateTimeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateDateTimeResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateDateTimeResponse") - kw["aname"] = "_UpdateDateTimeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateDateTimeResponse_Holder" - self.pyclass = Holder - - class RefreshDateTimeSystem_Dec(ElementDeclaration): - literal = "RefreshDateTimeSystem" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshDateTimeSystem") - kw["aname"] = "_RefreshDateTimeSystem" - if ns0.RefreshDateTimeSystemRequestType_Def not in ns0.RefreshDateTimeSystem_Dec.__bases__: - bases = list(ns0.RefreshDateTimeSystem_Dec.__bases__) - bases.insert(0, ns0.RefreshDateTimeSystemRequestType_Def) - ns0.RefreshDateTimeSystem_Dec.__bases__ = tuple(bases) - - ns0.RefreshDateTimeSystemRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshDateTimeSystem_Dec_Holder" - - class RefreshDateTimeSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshDateTimeSystemResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshDateTimeSystemResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshDateTimeSystemResponse") - kw["aname"] = "_RefreshDateTimeSystemResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshDateTimeSystemResponse_Holder" - self.pyclass = Holder - - class QueryAvailablePartition_Dec(ElementDeclaration): - literal = "QueryAvailablePartition" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryAvailablePartition") - kw["aname"] = "_QueryAvailablePartition" - if ns0.QueryAvailablePartitionRequestType_Def not in ns0.QueryAvailablePartition_Dec.__bases__: - bases = list(ns0.QueryAvailablePartition_Dec.__bases__) - bases.insert(0, ns0.QueryAvailablePartitionRequestType_Def) - ns0.QueryAvailablePartition_Dec.__bases__ = tuple(bases) - - ns0.QueryAvailablePartitionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryAvailablePartition_Dec_Holder" - - class QueryAvailablePartitionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryAvailablePartitionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryAvailablePartitionResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDiagnosticPartition",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryAvailablePartitionResponse") - kw["aname"] = "_QueryAvailablePartitionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryAvailablePartitionResponse_Holder" - self.pyclass = Holder - - class SelectActivePartition_Dec(ElementDeclaration): - literal = "SelectActivePartition" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SelectActivePartition") - kw["aname"] = "_SelectActivePartition" - if ns0.SelectActivePartitionRequestType_Def not in ns0.SelectActivePartition_Dec.__bases__: - bases = list(ns0.SelectActivePartition_Dec.__bases__) - bases.insert(0, ns0.SelectActivePartitionRequestType_Def) - ns0.SelectActivePartition_Dec.__bases__ = tuple(bases) - - ns0.SelectActivePartitionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SelectActivePartition_Dec_Holder" - - class SelectActivePartitionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SelectActivePartitionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SelectActivePartitionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SelectActivePartitionResponse") - kw["aname"] = "_SelectActivePartitionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SelectActivePartitionResponse_Holder" - self.pyclass = Holder - - class QueryPartitionCreateOptions_Dec(ElementDeclaration): - literal = "QueryPartitionCreateOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPartitionCreateOptions") - kw["aname"] = "_QueryPartitionCreateOptions" - if ns0.QueryPartitionCreateOptionsRequestType_Def not in ns0.QueryPartitionCreateOptions_Dec.__bases__: - bases = list(ns0.QueryPartitionCreateOptions_Dec.__bases__) - bases.insert(0, ns0.QueryPartitionCreateOptionsRequestType_Def) - ns0.QueryPartitionCreateOptions_Dec.__bases__ = tuple(bases) - - ns0.QueryPartitionCreateOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPartitionCreateOptions_Dec_Holder" - - class QueryPartitionCreateOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPartitionCreateOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPartitionCreateOptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDiagnosticPartitionCreateOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPartitionCreateOptionsResponse") - kw["aname"] = "_QueryPartitionCreateOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryPartitionCreateOptionsResponse_Holder" - self.pyclass = Holder - - class QueryPartitionCreateDesc_Dec(ElementDeclaration): - literal = "QueryPartitionCreateDesc" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPartitionCreateDesc") - kw["aname"] = "_QueryPartitionCreateDesc" - if ns0.QueryPartitionCreateDescRequestType_Def not in ns0.QueryPartitionCreateDesc_Dec.__bases__: - bases = list(ns0.QueryPartitionCreateDesc_Dec.__bases__) - bases.insert(0, ns0.QueryPartitionCreateDescRequestType_Def) - ns0.QueryPartitionCreateDesc_Dec.__bases__ = tuple(bases) - - ns0.QueryPartitionCreateDescRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPartitionCreateDesc_Dec_Holder" - - class QueryPartitionCreateDescResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPartitionCreateDescResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPartitionCreateDescResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDiagnosticPartitionCreateDescription",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPartitionCreateDescResponse") - kw["aname"] = "_QueryPartitionCreateDescResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryPartitionCreateDescResponse_Holder" - self.pyclass = Holder - - class CreateDiagnosticPartition_Dec(ElementDeclaration): - literal = "CreateDiagnosticPartition" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateDiagnosticPartition") - kw["aname"] = "_CreateDiagnosticPartition" - if ns0.CreateDiagnosticPartitionRequestType_Def not in ns0.CreateDiagnosticPartition_Dec.__bases__: - bases = list(ns0.CreateDiagnosticPartition_Dec.__bases__) - bases.insert(0, ns0.CreateDiagnosticPartitionRequestType_Def) - ns0.CreateDiagnosticPartition_Dec.__bases__ = tuple(bases) - - ns0.CreateDiagnosticPartitionRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateDiagnosticPartition_Dec_Holder" - - class CreateDiagnosticPartitionResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateDiagnosticPartitionResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateDiagnosticPartitionResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CreateDiagnosticPartitionResponse") - kw["aname"] = "_CreateDiagnosticPartitionResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CreateDiagnosticPartitionResponse_Holder" - self.pyclass = Holder - - class UpdateDefaultPolicy_Dec(ElementDeclaration): - literal = "UpdateDefaultPolicy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateDefaultPolicy") - kw["aname"] = "_UpdateDefaultPolicy" - if ns0.UpdateDefaultPolicyRequestType_Def not in ns0.UpdateDefaultPolicy_Dec.__bases__: - bases = list(ns0.UpdateDefaultPolicy_Dec.__bases__) - bases.insert(0, ns0.UpdateDefaultPolicyRequestType_Def) - ns0.UpdateDefaultPolicy_Dec.__bases__ = tuple(bases) - - ns0.UpdateDefaultPolicyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateDefaultPolicy_Dec_Holder" - - class UpdateDefaultPolicyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateDefaultPolicyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateDefaultPolicyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateDefaultPolicyResponse") - kw["aname"] = "_UpdateDefaultPolicyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateDefaultPolicyResponse_Holder" - self.pyclass = Holder - - class EnableRuleset_Dec(ElementDeclaration): - literal = "EnableRuleset" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnableRuleset") - kw["aname"] = "_EnableRuleset" - if ns0.EnableRulesetRequestType_Def not in ns0.EnableRuleset_Dec.__bases__: - bases = list(ns0.EnableRuleset_Dec.__bases__) - bases.insert(0, ns0.EnableRulesetRequestType_Def) - ns0.EnableRuleset_Dec.__bases__ = tuple(bases) - - ns0.EnableRulesetRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnableRuleset_Dec_Holder" - - class EnableRulesetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnableRulesetResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnableRulesetResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","EnableRulesetResponse") - kw["aname"] = "_EnableRulesetResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "EnableRulesetResponse_Holder" - self.pyclass = Holder - - class DisableRuleset_Dec(ElementDeclaration): - literal = "DisableRuleset" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisableRuleset") - kw["aname"] = "_DisableRuleset" - if ns0.DisableRulesetRequestType_Def not in ns0.DisableRuleset_Dec.__bases__: - bases = list(ns0.DisableRuleset_Dec.__bases__) - bases.insert(0, ns0.DisableRulesetRequestType_Def) - ns0.DisableRuleset_Dec.__bases__ = tuple(bases) - - ns0.DisableRulesetRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisableRuleset_Dec_Holder" - - class DisableRulesetResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisableRulesetResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisableRulesetResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DisableRulesetResponse") - kw["aname"] = "_DisableRulesetResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DisableRulesetResponse_Holder" - self.pyclass = Holder - - class RefreshFirewall_Dec(ElementDeclaration): - literal = "RefreshFirewall" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshFirewall") - kw["aname"] = "_RefreshFirewall" - if ns0.RefreshFirewallRequestType_Def not in ns0.RefreshFirewall_Dec.__bases__: - bases = list(ns0.RefreshFirewall_Dec.__bases__) - bases.insert(0, ns0.RefreshFirewallRequestType_Def) - ns0.RefreshFirewall_Dec.__bases__ = tuple(bases) - - ns0.RefreshFirewallRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshFirewall_Dec_Holder" - - class RefreshFirewallResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshFirewallResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshFirewallResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshFirewallResponse") - kw["aname"] = "_RefreshFirewallResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshFirewallResponse_Holder" - self.pyclass = Holder - - class ResetFirmwareToFactoryDefaults_Dec(ElementDeclaration): - literal = "ResetFirmwareToFactoryDefaults" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetFirmwareToFactoryDefaults") - kw["aname"] = "_ResetFirmwareToFactoryDefaults" - if ns0.ResetFirmwareToFactoryDefaultsRequestType_Def not in ns0.ResetFirmwareToFactoryDefaults_Dec.__bases__: - bases = list(ns0.ResetFirmwareToFactoryDefaults_Dec.__bases__) - bases.insert(0, ns0.ResetFirmwareToFactoryDefaultsRequestType_Def) - ns0.ResetFirmwareToFactoryDefaults_Dec.__bases__ = tuple(bases) - - ns0.ResetFirmwareToFactoryDefaultsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetFirmwareToFactoryDefaults_Dec_Holder" - - class ResetFirmwareToFactoryDefaultsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetFirmwareToFactoryDefaultsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetFirmwareToFactoryDefaultsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetFirmwareToFactoryDefaultsResponse") - kw["aname"] = "_ResetFirmwareToFactoryDefaultsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetFirmwareToFactoryDefaultsResponse_Holder" - self.pyclass = Holder - - class BackupFirmwareConfiguration_Dec(ElementDeclaration): - literal = "BackupFirmwareConfiguration" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","BackupFirmwareConfiguration") - kw["aname"] = "_BackupFirmwareConfiguration" - if ns0.BackupFirmwareConfigurationRequestType_Def not in ns0.BackupFirmwareConfiguration_Dec.__bases__: - bases = list(ns0.BackupFirmwareConfiguration_Dec.__bases__) - bases.insert(0, ns0.BackupFirmwareConfigurationRequestType_Def) - ns0.BackupFirmwareConfiguration_Dec.__bases__ = tuple(bases) - - ns0.BackupFirmwareConfigurationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "BackupFirmwareConfiguration_Dec_Holder" - - class BackupFirmwareConfigurationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "BackupFirmwareConfigurationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.BackupFirmwareConfigurationResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","BackupFirmwareConfigurationResponse") - kw["aname"] = "_BackupFirmwareConfigurationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "BackupFirmwareConfigurationResponse_Holder" - self.pyclass = Holder - - class QueryFirmwareConfigUploadURL_Dec(ElementDeclaration): - literal = "QueryFirmwareConfigUploadURL" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryFirmwareConfigUploadURL") - kw["aname"] = "_QueryFirmwareConfigUploadURL" - if ns0.QueryFirmwareConfigUploadURLRequestType_Def not in ns0.QueryFirmwareConfigUploadURL_Dec.__bases__: - bases = list(ns0.QueryFirmwareConfigUploadURL_Dec.__bases__) - bases.insert(0, ns0.QueryFirmwareConfigUploadURLRequestType_Def) - ns0.QueryFirmwareConfigUploadURL_Dec.__bases__ = tuple(bases) - - ns0.QueryFirmwareConfigUploadURLRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryFirmwareConfigUploadURL_Dec_Holder" - - class QueryFirmwareConfigUploadURLResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryFirmwareConfigUploadURLResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryFirmwareConfigUploadURLResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryFirmwareConfigUploadURLResponse") - kw["aname"] = "_QueryFirmwareConfigUploadURLResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryFirmwareConfigUploadURLResponse_Holder" - self.pyclass = Holder - - class RestoreFirmwareConfiguration_Dec(ElementDeclaration): - literal = "RestoreFirmwareConfiguration" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RestoreFirmwareConfiguration") - kw["aname"] = "_RestoreFirmwareConfiguration" - if ns0.RestoreFirmwareConfigurationRequestType_Def not in ns0.RestoreFirmwareConfiguration_Dec.__bases__: - bases = list(ns0.RestoreFirmwareConfiguration_Dec.__bases__) - bases.insert(0, ns0.RestoreFirmwareConfigurationRequestType_Def) - ns0.RestoreFirmwareConfiguration_Dec.__bases__ = tuple(bases) - - ns0.RestoreFirmwareConfigurationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RestoreFirmwareConfiguration_Dec_Holder" - - class RestoreFirmwareConfigurationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RestoreFirmwareConfigurationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RestoreFirmwareConfigurationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RestoreFirmwareConfigurationResponse") - kw["aname"] = "_RestoreFirmwareConfigurationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RestoreFirmwareConfigurationResponse_Holder" - self.pyclass = Holder - - class RefreshHealthStatusSystem_Dec(ElementDeclaration): - literal = "RefreshHealthStatusSystem" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshHealthStatusSystem") - kw["aname"] = "_RefreshHealthStatusSystem" - if ns0.RefreshHealthStatusSystemRequestType_Def not in ns0.RefreshHealthStatusSystem_Dec.__bases__: - bases = list(ns0.RefreshHealthStatusSystem_Dec.__bases__) - bases.insert(0, ns0.RefreshHealthStatusSystemRequestType_Def) - ns0.RefreshHealthStatusSystem_Dec.__bases__ = tuple(bases) - - ns0.RefreshHealthStatusSystemRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshHealthStatusSystem_Dec_Holder" - - class RefreshHealthStatusSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshHealthStatusSystemResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshHealthStatusSystemResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshHealthStatusSystemResponse") - kw["aname"] = "_RefreshHealthStatusSystemResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshHealthStatusSystemResponse_Holder" - self.pyclass = Holder - - class ResetSystemHealthInfo_Dec(ElementDeclaration): - literal = "ResetSystemHealthInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetSystemHealthInfo") - kw["aname"] = "_ResetSystemHealthInfo" - if ns0.ResetSystemHealthInfoRequestType_Def not in ns0.ResetSystemHealthInfo_Dec.__bases__: - bases = list(ns0.ResetSystemHealthInfo_Dec.__bases__) - bases.insert(0, ns0.ResetSystemHealthInfoRequestType_Def) - ns0.ResetSystemHealthInfo_Dec.__bases__ = tuple(bases) - - ns0.ResetSystemHealthInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetSystemHealthInfo_Dec_Holder" - - class ResetSystemHealthInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetSystemHealthInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetSystemHealthInfoResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetSystemHealthInfoResponse") - kw["aname"] = "_ResetSystemHealthInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetSystemHealthInfoResponse_Holder" - self.pyclass = Holder - - class QueryModules_Dec(ElementDeclaration): - literal = "QueryModules" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryModules") - kw["aname"] = "_QueryModules" - if ns0.QueryModulesRequestType_Def not in ns0.QueryModules_Dec.__bases__: - bases = list(ns0.QueryModules_Dec.__bases__) - bases.insert(0, ns0.QueryModulesRequestType_Def) - ns0.QueryModules_Dec.__bases__ = tuple(bases) - - ns0.QueryModulesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryModules_Dec_Holder" - - class QueryModulesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryModulesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryModulesResponse_Dec.schema - TClist = [GTD("urn:vim25","KernelModuleInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryModulesResponse") - kw["aname"] = "_QueryModulesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryModulesResponse_Holder" - self.pyclass = Holder - - class UpdateModuleOptionString_Dec(ElementDeclaration): - literal = "UpdateModuleOptionString" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateModuleOptionString") - kw["aname"] = "_UpdateModuleOptionString" - if ns0.UpdateModuleOptionStringRequestType_Def not in ns0.UpdateModuleOptionString_Dec.__bases__: - bases = list(ns0.UpdateModuleOptionString_Dec.__bases__) - bases.insert(0, ns0.UpdateModuleOptionStringRequestType_Def) - ns0.UpdateModuleOptionString_Dec.__bases__ = tuple(bases) - - ns0.UpdateModuleOptionStringRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateModuleOptionString_Dec_Holder" - - class UpdateModuleOptionStringResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateModuleOptionStringResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateModuleOptionStringResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateModuleOptionStringResponse") - kw["aname"] = "_UpdateModuleOptionStringResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateModuleOptionStringResponse_Holder" - self.pyclass = Holder - - class QueryConfiguredModuleOptionString_Dec(ElementDeclaration): - literal = "QueryConfiguredModuleOptionString" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryConfiguredModuleOptionString") - kw["aname"] = "_QueryConfiguredModuleOptionString" - if ns0.QueryConfiguredModuleOptionStringRequestType_Def not in ns0.QueryConfiguredModuleOptionString_Dec.__bases__: - bases = list(ns0.QueryConfiguredModuleOptionString_Dec.__bases__) - bases.insert(0, ns0.QueryConfiguredModuleOptionStringRequestType_Def) - ns0.QueryConfiguredModuleOptionString_Dec.__bases__ = tuple(bases) - - ns0.QueryConfiguredModuleOptionStringRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryConfiguredModuleOptionString_Dec_Holder" - - class QueryConfiguredModuleOptionStringResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryConfiguredModuleOptionStringResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryConfiguredModuleOptionStringResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryConfiguredModuleOptionStringResponse") - kw["aname"] = "_QueryConfiguredModuleOptionStringResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryConfiguredModuleOptionStringResponse_Holder" - self.pyclass = Holder - - class CreateUser_Dec(ElementDeclaration): - literal = "CreateUser" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateUser") - kw["aname"] = "_CreateUser" - if ns0.CreateUserRequestType_Def not in ns0.CreateUser_Dec.__bases__: - bases = list(ns0.CreateUser_Dec.__bases__) - bases.insert(0, ns0.CreateUserRequestType_Def) - ns0.CreateUser_Dec.__bases__ = tuple(bases) - - ns0.CreateUserRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateUser_Dec_Holder" - - class CreateUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateUserResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateUserResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CreateUserResponse") - kw["aname"] = "_CreateUserResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CreateUserResponse_Holder" - self.pyclass = Holder - - class UpdateUser_Dec(ElementDeclaration): - literal = "UpdateUser" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateUser") - kw["aname"] = "_UpdateUser" - if ns0.UpdateUserRequestType_Def not in ns0.UpdateUser_Dec.__bases__: - bases = list(ns0.UpdateUser_Dec.__bases__) - bases.insert(0, ns0.UpdateUserRequestType_Def) - ns0.UpdateUser_Dec.__bases__ = tuple(bases) - - ns0.UpdateUserRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateUser_Dec_Holder" - - class UpdateUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateUserResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateUserResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateUserResponse") - kw["aname"] = "_UpdateUserResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateUserResponse_Holder" - self.pyclass = Holder - - class CreateGroup_Dec(ElementDeclaration): - literal = "CreateGroup" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateGroup") - kw["aname"] = "_CreateGroup" - if ns0.CreateGroupRequestType_Def not in ns0.CreateGroup_Dec.__bases__: - bases = list(ns0.CreateGroup_Dec.__bases__) - bases.insert(0, ns0.CreateGroupRequestType_Def) - ns0.CreateGroup_Dec.__bases__ = tuple(bases) - - ns0.CreateGroupRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateGroup_Dec_Holder" - - class CreateGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateGroupResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateGroupResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","CreateGroupResponse") - kw["aname"] = "_CreateGroupResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "CreateGroupResponse_Holder" - self.pyclass = Holder - - class RemoveUser_Dec(ElementDeclaration): - literal = "RemoveUser" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveUser") - kw["aname"] = "_RemoveUser" - if ns0.RemoveUserRequestType_Def not in ns0.RemoveUser_Dec.__bases__: - bases = list(ns0.RemoveUser_Dec.__bases__) - bases.insert(0, ns0.RemoveUserRequestType_Def) - ns0.RemoveUser_Dec.__bases__ = tuple(bases) - - ns0.RemoveUserRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveUser_Dec_Holder" - - class RemoveUserResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveUserResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveUserResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveUserResponse") - kw["aname"] = "_RemoveUserResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveUserResponse_Holder" - self.pyclass = Holder - - class RemoveGroup_Dec(ElementDeclaration): - literal = "RemoveGroup" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveGroup") - kw["aname"] = "_RemoveGroup" - if ns0.RemoveGroupRequestType_Def not in ns0.RemoveGroup_Dec.__bases__: - bases = list(ns0.RemoveGroup_Dec.__bases__) - bases.insert(0, ns0.RemoveGroupRequestType_Def) - ns0.RemoveGroup_Dec.__bases__ = tuple(bases) - - ns0.RemoveGroupRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveGroup_Dec_Holder" - - class RemoveGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveGroupResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveGroupResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveGroupResponse") - kw["aname"] = "_RemoveGroupResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveGroupResponse_Holder" - self.pyclass = Holder - - class AssignUserToGroup_Dec(ElementDeclaration): - literal = "AssignUserToGroup" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AssignUserToGroup") - kw["aname"] = "_AssignUserToGroup" - if ns0.AssignUserToGroupRequestType_Def not in ns0.AssignUserToGroup_Dec.__bases__: - bases = list(ns0.AssignUserToGroup_Dec.__bases__) - bases.insert(0, ns0.AssignUserToGroupRequestType_Def) - ns0.AssignUserToGroup_Dec.__bases__ = tuple(bases) - - ns0.AssignUserToGroupRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AssignUserToGroup_Dec_Holder" - - class AssignUserToGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AssignUserToGroupResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AssignUserToGroupResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AssignUserToGroupResponse") - kw["aname"] = "_AssignUserToGroupResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AssignUserToGroupResponse_Holder" - self.pyclass = Holder - - class UnassignUserFromGroup_Dec(ElementDeclaration): - literal = "UnassignUserFromGroup" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnassignUserFromGroup") - kw["aname"] = "_UnassignUserFromGroup" - if ns0.UnassignUserFromGroupRequestType_Def not in ns0.UnassignUserFromGroup_Dec.__bases__: - bases = list(ns0.UnassignUserFromGroup_Dec.__bases__) - bases.insert(0, ns0.UnassignUserFromGroupRequestType_Def) - ns0.UnassignUserFromGroup_Dec.__bases__ = tuple(bases) - - ns0.UnassignUserFromGroupRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnassignUserFromGroup_Dec_Holder" - - class UnassignUserFromGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UnassignUserFromGroupResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UnassignUserFromGroupResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UnassignUserFromGroupResponse") - kw["aname"] = "_UnassignUserFromGroupResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UnassignUserFromGroupResponse_Holder" - self.pyclass = Holder - - class ReconfigureServiceConsoleReservation_Dec(ElementDeclaration): - literal = "ReconfigureServiceConsoleReservation" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureServiceConsoleReservation") - kw["aname"] = "_ReconfigureServiceConsoleReservation" - if ns0.ReconfigureServiceConsoleReservationRequestType_Def not in ns0.ReconfigureServiceConsoleReservation_Dec.__bases__: - bases = list(ns0.ReconfigureServiceConsoleReservation_Dec.__bases__) - bases.insert(0, ns0.ReconfigureServiceConsoleReservationRequestType_Def) - ns0.ReconfigureServiceConsoleReservation_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureServiceConsoleReservationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureServiceConsoleReservation_Dec_Holder" - - class ReconfigureServiceConsoleReservationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureServiceConsoleReservationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureServiceConsoleReservationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureServiceConsoleReservationResponse") - kw["aname"] = "_ReconfigureServiceConsoleReservationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureServiceConsoleReservationResponse_Holder" - self.pyclass = Holder - - class ReconfigureVirtualMachineReservation_Dec(ElementDeclaration): - literal = "ReconfigureVirtualMachineReservation" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureVirtualMachineReservation") - kw["aname"] = "_ReconfigureVirtualMachineReservation" - if ns0.ReconfigureVirtualMachineReservationRequestType_Def not in ns0.ReconfigureVirtualMachineReservation_Dec.__bases__: - bases = list(ns0.ReconfigureVirtualMachineReservation_Dec.__bases__) - bases.insert(0, ns0.ReconfigureVirtualMachineReservationRequestType_Def) - ns0.ReconfigureVirtualMachineReservation_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureVirtualMachineReservationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureVirtualMachineReservation_Dec_Holder" - - class ReconfigureVirtualMachineReservationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureVirtualMachineReservationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureVirtualMachineReservationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureVirtualMachineReservationResponse") - kw["aname"] = "_ReconfigureVirtualMachineReservationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureVirtualMachineReservationResponse_Holder" - self.pyclass = Holder - - class UpdateNetworkConfig_Dec(ElementDeclaration): - literal = "UpdateNetworkConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateNetworkConfig") - kw["aname"] = "_UpdateNetworkConfig" - if ns0.UpdateNetworkConfigRequestType_Def not in ns0.UpdateNetworkConfig_Dec.__bases__: - bases = list(ns0.UpdateNetworkConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateNetworkConfigRequestType_Def) - ns0.UpdateNetworkConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateNetworkConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateNetworkConfig_Dec_Holder" - - class UpdateNetworkConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateNetworkConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateNetworkConfigResponse_Dec.schema - TClist = [GTD("urn:vim25","HostNetworkConfigResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UpdateNetworkConfigResponse") - kw["aname"] = "_UpdateNetworkConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UpdateNetworkConfigResponse_Holder" - self.pyclass = Holder - - class UpdateDnsConfig_Dec(ElementDeclaration): - literal = "UpdateDnsConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateDnsConfig") - kw["aname"] = "_UpdateDnsConfig" - if ns0.UpdateDnsConfigRequestType_Def not in ns0.UpdateDnsConfig_Dec.__bases__: - bases = list(ns0.UpdateDnsConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateDnsConfigRequestType_Def) - ns0.UpdateDnsConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateDnsConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateDnsConfig_Dec_Holder" - - class UpdateDnsConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateDnsConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateDnsConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateDnsConfigResponse") - kw["aname"] = "_UpdateDnsConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateDnsConfigResponse_Holder" - self.pyclass = Holder - - class UpdateIpRouteConfig_Dec(ElementDeclaration): - literal = "UpdateIpRouteConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateIpRouteConfig") - kw["aname"] = "_UpdateIpRouteConfig" - if ns0.UpdateIpRouteConfigRequestType_Def not in ns0.UpdateIpRouteConfig_Dec.__bases__: - bases = list(ns0.UpdateIpRouteConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateIpRouteConfigRequestType_Def) - ns0.UpdateIpRouteConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateIpRouteConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpRouteConfig_Dec_Holder" - - class UpdateIpRouteConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateIpRouteConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateIpRouteConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateIpRouteConfigResponse") - kw["aname"] = "_UpdateIpRouteConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateIpRouteConfigResponse_Holder" - self.pyclass = Holder - - class UpdateConsoleIpRouteConfig_Dec(ElementDeclaration): - literal = "UpdateConsoleIpRouteConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateConsoleIpRouteConfig") - kw["aname"] = "_UpdateConsoleIpRouteConfig" - if ns0.UpdateConsoleIpRouteConfigRequestType_Def not in ns0.UpdateConsoleIpRouteConfig_Dec.__bases__: - bases = list(ns0.UpdateConsoleIpRouteConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateConsoleIpRouteConfigRequestType_Def) - ns0.UpdateConsoleIpRouteConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateConsoleIpRouteConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateConsoleIpRouteConfig_Dec_Holder" - - class UpdateConsoleIpRouteConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateConsoleIpRouteConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateConsoleIpRouteConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateConsoleIpRouteConfigResponse") - kw["aname"] = "_UpdateConsoleIpRouteConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateConsoleIpRouteConfigResponse_Holder" - self.pyclass = Holder - - class UpdateIpRouteTableConfig_Dec(ElementDeclaration): - literal = "UpdateIpRouteTableConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateIpRouteTableConfig") - kw["aname"] = "_UpdateIpRouteTableConfig" - if ns0.UpdateIpRouteTableConfigRequestType_Def not in ns0.UpdateIpRouteTableConfig_Dec.__bases__: - bases = list(ns0.UpdateIpRouteTableConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateIpRouteTableConfigRequestType_Def) - ns0.UpdateIpRouteTableConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateIpRouteTableConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpRouteTableConfig_Dec_Holder" - - class UpdateIpRouteTableConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateIpRouteTableConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateIpRouteTableConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateIpRouteTableConfigResponse") - kw["aname"] = "_UpdateIpRouteTableConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateIpRouteTableConfigResponse_Holder" - self.pyclass = Holder - - class AddVirtualSwitch_Dec(ElementDeclaration): - literal = "AddVirtualSwitch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddVirtualSwitch") - kw["aname"] = "_AddVirtualSwitch" - if ns0.AddVirtualSwitchRequestType_Def not in ns0.AddVirtualSwitch_Dec.__bases__: - bases = list(ns0.AddVirtualSwitch_Dec.__bases__) - bases.insert(0, ns0.AddVirtualSwitchRequestType_Def) - ns0.AddVirtualSwitch_Dec.__bases__ = tuple(bases) - - ns0.AddVirtualSwitchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddVirtualSwitch_Dec_Holder" - - class AddVirtualSwitchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddVirtualSwitchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddVirtualSwitchResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AddVirtualSwitchResponse") - kw["aname"] = "_AddVirtualSwitchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AddVirtualSwitchResponse_Holder" - self.pyclass = Holder - - class RemoveVirtualSwitch_Dec(ElementDeclaration): - literal = "RemoveVirtualSwitch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveVirtualSwitch") - kw["aname"] = "_RemoveVirtualSwitch" - if ns0.RemoveVirtualSwitchRequestType_Def not in ns0.RemoveVirtualSwitch_Dec.__bases__: - bases = list(ns0.RemoveVirtualSwitch_Dec.__bases__) - bases.insert(0, ns0.RemoveVirtualSwitchRequestType_Def) - ns0.RemoveVirtualSwitch_Dec.__bases__ = tuple(bases) - - ns0.RemoveVirtualSwitchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveVirtualSwitch_Dec_Holder" - - class RemoveVirtualSwitchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveVirtualSwitchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveVirtualSwitchResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveVirtualSwitchResponse") - kw["aname"] = "_RemoveVirtualSwitchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveVirtualSwitchResponse_Holder" - self.pyclass = Holder - - class UpdateVirtualSwitch_Dec(ElementDeclaration): - literal = "UpdateVirtualSwitch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateVirtualSwitch") - kw["aname"] = "_UpdateVirtualSwitch" - if ns0.UpdateVirtualSwitchRequestType_Def not in ns0.UpdateVirtualSwitch_Dec.__bases__: - bases = list(ns0.UpdateVirtualSwitch_Dec.__bases__) - bases.insert(0, ns0.UpdateVirtualSwitchRequestType_Def) - ns0.UpdateVirtualSwitch_Dec.__bases__ = tuple(bases) - - ns0.UpdateVirtualSwitchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateVirtualSwitch_Dec_Holder" - - class UpdateVirtualSwitchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateVirtualSwitchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateVirtualSwitchResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateVirtualSwitchResponse") - kw["aname"] = "_UpdateVirtualSwitchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateVirtualSwitchResponse_Holder" - self.pyclass = Holder - - class AddPortGroup_Dec(ElementDeclaration): - literal = "AddPortGroup" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddPortGroup") - kw["aname"] = "_AddPortGroup" - if ns0.AddPortGroupRequestType_Def not in ns0.AddPortGroup_Dec.__bases__: - bases = list(ns0.AddPortGroup_Dec.__bases__) - bases.insert(0, ns0.AddPortGroupRequestType_Def) - ns0.AddPortGroup_Dec.__bases__ = tuple(bases) - - ns0.AddPortGroupRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddPortGroup_Dec_Holder" - - class AddPortGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddPortGroupResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddPortGroupResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AddPortGroupResponse") - kw["aname"] = "_AddPortGroupResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AddPortGroupResponse_Holder" - self.pyclass = Holder - - class RemovePortGroup_Dec(ElementDeclaration): - literal = "RemovePortGroup" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemovePortGroup") - kw["aname"] = "_RemovePortGroup" - if ns0.RemovePortGroupRequestType_Def not in ns0.RemovePortGroup_Dec.__bases__: - bases = list(ns0.RemovePortGroup_Dec.__bases__) - bases.insert(0, ns0.RemovePortGroupRequestType_Def) - ns0.RemovePortGroup_Dec.__bases__ = tuple(bases) - - ns0.RemovePortGroupRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemovePortGroup_Dec_Holder" - - class RemovePortGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemovePortGroupResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemovePortGroupResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemovePortGroupResponse") - kw["aname"] = "_RemovePortGroupResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemovePortGroupResponse_Holder" - self.pyclass = Holder - - class UpdatePortGroup_Dec(ElementDeclaration): - literal = "UpdatePortGroup" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdatePortGroup") - kw["aname"] = "_UpdatePortGroup" - if ns0.UpdatePortGroupRequestType_Def not in ns0.UpdatePortGroup_Dec.__bases__: - bases = list(ns0.UpdatePortGroup_Dec.__bases__) - bases.insert(0, ns0.UpdatePortGroupRequestType_Def) - ns0.UpdatePortGroup_Dec.__bases__ = tuple(bases) - - ns0.UpdatePortGroupRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdatePortGroup_Dec_Holder" - - class UpdatePortGroupResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdatePortGroupResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdatePortGroupResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdatePortGroupResponse") - kw["aname"] = "_UpdatePortGroupResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdatePortGroupResponse_Holder" - self.pyclass = Holder - - class UpdatePhysicalNicLinkSpeed_Dec(ElementDeclaration): - literal = "UpdatePhysicalNicLinkSpeed" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdatePhysicalNicLinkSpeed") - kw["aname"] = "_UpdatePhysicalNicLinkSpeed" - if ns0.UpdatePhysicalNicLinkSpeedRequestType_Def not in ns0.UpdatePhysicalNicLinkSpeed_Dec.__bases__: - bases = list(ns0.UpdatePhysicalNicLinkSpeed_Dec.__bases__) - bases.insert(0, ns0.UpdatePhysicalNicLinkSpeedRequestType_Def) - ns0.UpdatePhysicalNicLinkSpeed_Dec.__bases__ = tuple(bases) - - ns0.UpdatePhysicalNicLinkSpeedRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdatePhysicalNicLinkSpeed_Dec_Holder" - - class UpdatePhysicalNicLinkSpeedResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdatePhysicalNicLinkSpeedResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdatePhysicalNicLinkSpeedResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdatePhysicalNicLinkSpeedResponse") - kw["aname"] = "_UpdatePhysicalNicLinkSpeedResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdatePhysicalNicLinkSpeedResponse_Holder" - self.pyclass = Holder - - class QueryNetworkHint_Dec(ElementDeclaration): - literal = "QueryNetworkHint" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryNetworkHint") - kw["aname"] = "_QueryNetworkHint" - if ns0.QueryNetworkHintRequestType_Def not in ns0.QueryNetworkHint_Dec.__bases__: - bases = list(ns0.QueryNetworkHint_Dec.__bases__) - bases.insert(0, ns0.QueryNetworkHintRequestType_Def) - ns0.QueryNetworkHint_Dec.__bases__ = tuple(bases) - - ns0.QueryNetworkHintRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryNetworkHint_Dec_Holder" - - class QueryNetworkHintResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryNetworkHintResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryNetworkHintResponse_Dec.schema - TClist = [GTD("urn:vim25","PhysicalNicHintInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryNetworkHintResponse") - kw["aname"] = "_QueryNetworkHintResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryNetworkHintResponse_Holder" - self.pyclass = Holder - - class AddVirtualNic_Dec(ElementDeclaration): - literal = "AddVirtualNic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddVirtualNic") - kw["aname"] = "_AddVirtualNic" - if ns0.AddVirtualNicRequestType_Def not in ns0.AddVirtualNic_Dec.__bases__: - bases = list(ns0.AddVirtualNic_Dec.__bases__) - bases.insert(0, ns0.AddVirtualNicRequestType_Def) - ns0.AddVirtualNic_Dec.__bases__ = tuple(bases) - - ns0.AddVirtualNicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddVirtualNic_Dec_Holder" - - class AddVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddVirtualNicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddVirtualNicResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddVirtualNicResponse") - kw["aname"] = "_AddVirtualNicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddVirtualNicResponse_Holder" - self.pyclass = Holder - - class RemoveVirtualNic_Dec(ElementDeclaration): - literal = "RemoveVirtualNic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveVirtualNic") - kw["aname"] = "_RemoveVirtualNic" - if ns0.RemoveVirtualNicRequestType_Def not in ns0.RemoveVirtualNic_Dec.__bases__: - bases = list(ns0.RemoveVirtualNic_Dec.__bases__) - bases.insert(0, ns0.RemoveVirtualNicRequestType_Def) - ns0.RemoveVirtualNic_Dec.__bases__ = tuple(bases) - - ns0.RemoveVirtualNicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveVirtualNic_Dec_Holder" - - class RemoveVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveVirtualNicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveVirtualNicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveVirtualNicResponse") - kw["aname"] = "_RemoveVirtualNicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveVirtualNicResponse_Holder" - self.pyclass = Holder - - class UpdateVirtualNic_Dec(ElementDeclaration): - literal = "UpdateVirtualNic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateVirtualNic") - kw["aname"] = "_UpdateVirtualNic" - if ns0.UpdateVirtualNicRequestType_Def not in ns0.UpdateVirtualNic_Dec.__bases__: - bases = list(ns0.UpdateVirtualNic_Dec.__bases__) - bases.insert(0, ns0.UpdateVirtualNicRequestType_Def) - ns0.UpdateVirtualNic_Dec.__bases__ = tuple(bases) - - ns0.UpdateVirtualNicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateVirtualNic_Dec_Holder" - - class UpdateVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateVirtualNicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateVirtualNicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateVirtualNicResponse") - kw["aname"] = "_UpdateVirtualNicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateVirtualNicResponse_Holder" - self.pyclass = Holder - - class AddServiceConsoleVirtualNic_Dec(ElementDeclaration): - literal = "AddServiceConsoleVirtualNic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddServiceConsoleVirtualNic") - kw["aname"] = "_AddServiceConsoleVirtualNic" - if ns0.AddServiceConsoleVirtualNicRequestType_Def not in ns0.AddServiceConsoleVirtualNic_Dec.__bases__: - bases = list(ns0.AddServiceConsoleVirtualNic_Dec.__bases__) - bases.insert(0, ns0.AddServiceConsoleVirtualNicRequestType_Def) - ns0.AddServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) - - ns0.AddServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddServiceConsoleVirtualNic_Dec_Holder" - - class AddServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddServiceConsoleVirtualNicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddServiceConsoleVirtualNicResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","AddServiceConsoleVirtualNicResponse") - kw["aname"] = "_AddServiceConsoleVirtualNicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "AddServiceConsoleVirtualNicResponse_Holder" - self.pyclass = Holder - - class RemoveServiceConsoleVirtualNic_Dec(ElementDeclaration): - literal = "RemoveServiceConsoleVirtualNic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveServiceConsoleVirtualNic") - kw["aname"] = "_RemoveServiceConsoleVirtualNic" - if ns0.RemoveServiceConsoleVirtualNicRequestType_Def not in ns0.RemoveServiceConsoleVirtualNic_Dec.__bases__: - bases = list(ns0.RemoveServiceConsoleVirtualNic_Dec.__bases__) - bases.insert(0, ns0.RemoveServiceConsoleVirtualNicRequestType_Def) - ns0.RemoveServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) - - ns0.RemoveServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveServiceConsoleVirtualNic_Dec_Holder" - - class RemoveServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveServiceConsoleVirtualNicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveServiceConsoleVirtualNicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveServiceConsoleVirtualNicResponse") - kw["aname"] = "_RemoveServiceConsoleVirtualNicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveServiceConsoleVirtualNicResponse_Holder" - self.pyclass = Holder - - class UpdateServiceConsoleVirtualNic_Dec(ElementDeclaration): - literal = "UpdateServiceConsoleVirtualNic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateServiceConsoleVirtualNic") - kw["aname"] = "_UpdateServiceConsoleVirtualNic" - if ns0.UpdateServiceConsoleVirtualNicRequestType_Def not in ns0.UpdateServiceConsoleVirtualNic_Dec.__bases__: - bases = list(ns0.UpdateServiceConsoleVirtualNic_Dec.__bases__) - bases.insert(0, ns0.UpdateServiceConsoleVirtualNicRequestType_Def) - ns0.UpdateServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) - - ns0.UpdateServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateServiceConsoleVirtualNic_Dec_Holder" - - class UpdateServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateServiceConsoleVirtualNicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateServiceConsoleVirtualNicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateServiceConsoleVirtualNicResponse") - kw["aname"] = "_UpdateServiceConsoleVirtualNicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateServiceConsoleVirtualNicResponse_Holder" - self.pyclass = Holder - - class RestartServiceConsoleVirtualNic_Dec(ElementDeclaration): - literal = "RestartServiceConsoleVirtualNic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RestartServiceConsoleVirtualNic") - kw["aname"] = "_RestartServiceConsoleVirtualNic" - if ns0.RestartServiceConsoleVirtualNicRequestType_Def not in ns0.RestartServiceConsoleVirtualNic_Dec.__bases__: - bases = list(ns0.RestartServiceConsoleVirtualNic_Dec.__bases__) - bases.insert(0, ns0.RestartServiceConsoleVirtualNicRequestType_Def) - ns0.RestartServiceConsoleVirtualNic_Dec.__bases__ = tuple(bases) - - ns0.RestartServiceConsoleVirtualNicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RestartServiceConsoleVirtualNic_Dec_Holder" - - class RestartServiceConsoleVirtualNicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RestartServiceConsoleVirtualNicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RestartServiceConsoleVirtualNicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RestartServiceConsoleVirtualNicResponse") - kw["aname"] = "_RestartServiceConsoleVirtualNicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RestartServiceConsoleVirtualNicResponse_Holder" - self.pyclass = Holder - - class RefreshNetworkSystem_Dec(ElementDeclaration): - literal = "RefreshNetworkSystem" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshNetworkSystem") - kw["aname"] = "_RefreshNetworkSystem" - if ns0.RefreshNetworkSystemRequestType_Def not in ns0.RefreshNetworkSystem_Dec.__bases__: - bases = list(ns0.RefreshNetworkSystem_Dec.__bases__) - bases.insert(0, ns0.RefreshNetworkSystemRequestType_Def) - ns0.RefreshNetworkSystem_Dec.__bases__ = tuple(bases) - - ns0.RefreshNetworkSystemRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshNetworkSystem_Dec_Holder" - - class RefreshNetworkSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshNetworkSystemResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshNetworkSystemResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshNetworkSystemResponse") - kw["aname"] = "_RefreshNetworkSystemResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshNetworkSystemResponse_Holder" - self.pyclass = Holder - - class CheckHostPatch_Dec(ElementDeclaration): - literal = "CheckHostPatch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckHostPatch") - kw["aname"] = "_CheckHostPatch" - if ns0.CheckHostPatchRequestType_Def not in ns0.CheckHostPatch_Dec.__bases__: - bases = list(ns0.CheckHostPatch_Dec.__bases__) - bases.insert(0, ns0.CheckHostPatchRequestType_Def) - ns0.CheckHostPatch_Dec.__bases__ = tuple(bases) - - ns0.CheckHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckHostPatch_Dec_Holder" - - class CheckHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckHostPatchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckHostPatchResponse_Dec.schema - TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckHostPatchResponse") - kw["aname"] = "_CheckHostPatchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CheckHostPatchResponse_Holder" - self.pyclass = Holder - - class CheckHostPatch_Task_Dec(ElementDeclaration): - literal = "CheckHostPatch_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckHostPatch_Task") - kw["aname"] = "_CheckHostPatch_Task" - if ns0.CheckHostPatchRequestType_Def not in ns0.CheckHostPatch_Task_Dec.__bases__: - bases = list(ns0.CheckHostPatch_Task_Dec.__bases__) - bases.insert(0, ns0.CheckHostPatchRequestType_Def) - ns0.CheckHostPatch_Task_Dec.__bases__ = tuple(bases) - - ns0.CheckHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckHostPatch_Task_Dec_Holder" - - class CheckHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckHostPatch_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckHostPatch_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckHostPatch_TaskResponse") - kw["aname"] = "_CheckHostPatch_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CheckHostPatch_TaskResponse_Holder" - self.pyclass = Holder - - class ScanHostPatch_Dec(ElementDeclaration): - literal = "ScanHostPatch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ScanHostPatch") - kw["aname"] = "_ScanHostPatch" - if ns0.ScanHostPatchRequestType_Def not in ns0.ScanHostPatch_Dec.__bases__: - bases = list(ns0.ScanHostPatch_Dec.__bases__) - bases.insert(0, ns0.ScanHostPatchRequestType_Def) - ns0.ScanHostPatch_Dec.__bases__ = tuple(bases) - - ns0.ScanHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatch_Dec_Holder" - - class ScanHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ScanHostPatchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ScanHostPatchResponse_Dec.schema - TClist = [GTD("urn:vim25","HostPatchManagerStatus",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ScanHostPatchResponse") - kw["aname"] = "_ScanHostPatchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ScanHostPatchResponse_Holder" - self.pyclass = Holder - - class ScanHostPatch_Task_Dec(ElementDeclaration): - literal = "ScanHostPatch_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ScanHostPatch_Task") - kw["aname"] = "_ScanHostPatch_Task" - if ns0.ScanHostPatchRequestType_Def not in ns0.ScanHostPatch_Task_Dec.__bases__: - bases = list(ns0.ScanHostPatch_Task_Dec.__bases__) - bases.insert(0, ns0.ScanHostPatchRequestType_Def) - ns0.ScanHostPatch_Task_Dec.__bases__ = tuple(bases) - - ns0.ScanHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatch_Task_Dec_Holder" - - class ScanHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ScanHostPatch_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ScanHostPatch_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ScanHostPatch_TaskResponse") - kw["aname"] = "_ScanHostPatch_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ScanHostPatch_TaskResponse_Holder" - self.pyclass = Holder - - class ScanHostPatchV2_Dec(ElementDeclaration): - literal = "ScanHostPatchV2" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ScanHostPatchV2") - kw["aname"] = "_ScanHostPatchV2" - if ns0.ScanHostPatchV2RequestType_Def not in ns0.ScanHostPatchV2_Dec.__bases__: - bases = list(ns0.ScanHostPatchV2_Dec.__bases__) - bases.insert(0, ns0.ScanHostPatchV2RequestType_Def) - ns0.ScanHostPatchV2_Dec.__bases__ = tuple(bases) - - ns0.ScanHostPatchV2RequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatchV2_Dec_Holder" - - class ScanHostPatchV2Response_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ScanHostPatchV2Response" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ScanHostPatchV2Response_Dec.schema - TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ScanHostPatchV2Response") - kw["aname"] = "_ScanHostPatchV2Response" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ScanHostPatchV2Response_Holder" - self.pyclass = Holder - - class ScanHostPatchV2_Task_Dec(ElementDeclaration): - literal = "ScanHostPatchV2_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ScanHostPatchV2_Task") - kw["aname"] = "_ScanHostPatchV2_Task" - if ns0.ScanHostPatchV2RequestType_Def not in ns0.ScanHostPatchV2_Task_Dec.__bases__: - bases = list(ns0.ScanHostPatchV2_Task_Dec.__bases__) - bases.insert(0, ns0.ScanHostPatchV2RequestType_Def) - ns0.ScanHostPatchV2_Task_Dec.__bases__ = tuple(bases) - - ns0.ScanHostPatchV2RequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ScanHostPatchV2_Task_Dec_Holder" - - class ScanHostPatchV2_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ScanHostPatchV2_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ScanHostPatchV2_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ScanHostPatchV2_TaskResponse") - kw["aname"] = "_ScanHostPatchV2_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ScanHostPatchV2_TaskResponse_Holder" - self.pyclass = Holder - - class StageHostPatch_Dec(ElementDeclaration): - literal = "StageHostPatch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StageHostPatch") - kw["aname"] = "_StageHostPatch" - if ns0.StageHostPatchRequestType_Def not in ns0.StageHostPatch_Dec.__bases__: - bases = list(ns0.StageHostPatch_Dec.__bases__) - bases.insert(0, ns0.StageHostPatchRequestType_Def) - ns0.StageHostPatch_Dec.__bases__ = tuple(bases) - - ns0.StageHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StageHostPatch_Dec_Holder" - - class StageHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StageHostPatchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StageHostPatchResponse_Dec.schema - TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","StageHostPatchResponse") - kw["aname"] = "_StageHostPatchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "StageHostPatchResponse_Holder" - self.pyclass = Holder - - class StageHostPatch_Task_Dec(ElementDeclaration): - literal = "StageHostPatch_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StageHostPatch_Task") - kw["aname"] = "_StageHostPatch_Task" - if ns0.StageHostPatchRequestType_Def not in ns0.StageHostPatch_Task_Dec.__bases__: - bases = list(ns0.StageHostPatch_Task_Dec.__bases__) - bases.insert(0, ns0.StageHostPatchRequestType_Def) - ns0.StageHostPatch_Task_Dec.__bases__ = tuple(bases) - - ns0.StageHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StageHostPatch_Task_Dec_Holder" - - class StageHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StageHostPatch_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StageHostPatch_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","StageHostPatch_TaskResponse") - kw["aname"] = "_StageHostPatch_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "StageHostPatch_TaskResponse_Holder" - self.pyclass = Holder - - class InstallHostPatch_Dec(ElementDeclaration): - literal = "InstallHostPatch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InstallHostPatch") - kw["aname"] = "_InstallHostPatch" - if ns0.InstallHostPatchRequestType_Def not in ns0.InstallHostPatch_Dec.__bases__: - bases = list(ns0.InstallHostPatch_Dec.__bases__) - bases.insert(0, ns0.InstallHostPatchRequestType_Def) - ns0.InstallHostPatch_Dec.__bases__ = tuple(bases) - - ns0.InstallHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatch_Dec_Holder" - - class InstallHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "InstallHostPatchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.InstallHostPatchResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","InstallHostPatchResponse") - kw["aname"] = "_InstallHostPatchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "InstallHostPatchResponse_Holder" - self.pyclass = Holder - - class InstallHostPatch_Task_Dec(ElementDeclaration): - literal = "InstallHostPatch_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InstallHostPatch_Task") - kw["aname"] = "_InstallHostPatch_Task" - if ns0.InstallHostPatchRequestType_Def not in ns0.InstallHostPatch_Task_Dec.__bases__: - bases = list(ns0.InstallHostPatch_Task_Dec.__bases__) - bases.insert(0, ns0.InstallHostPatchRequestType_Def) - ns0.InstallHostPatch_Task_Dec.__bases__ = tuple(bases) - - ns0.InstallHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatch_Task_Dec_Holder" - - class InstallHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "InstallHostPatch_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.InstallHostPatch_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","InstallHostPatch_TaskResponse") - kw["aname"] = "_InstallHostPatch_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "InstallHostPatch_TaskResponse_Holder" - self.pyclass = Holder - - class InstallHostPatchV2_Dec(ElementDeclaration): - literal = "InstallHostPatchV2" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InstallHostPatchV2") - kw["aname"] = "_InstallHostPatchV2" - if ns0.InstallHostPatchV2RequestType_Def not in ns0.InstallHostPatchV2_Dec.__bases__: - bases = list(ns0.InstallHostPatchV2_Dec.__bases__) - bases.insert(0, ns0.InstallHostPatchV2RequestType_Def) - ns0.InstallHostPatchV2_Dec.__bases__ = tuple(bases) - - ns0.InstallHostPatchV2RequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatchV2_Dec_Holder" - - class InstallHostPatchV2Response_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "InstallHostPatchV2Response" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.InstallHostPatchV2Response_Dec.schema - TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","InstallHostPatchV2Response") - kw["aname"] = "_InstallHostPatchV2Response" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "InstallHostPatchV2Response_Holder" - self.pyclass = Holder - - class InstallHostPatchV2_Task_Dec(ElementDeclaration): - literal = "InstallHostPatchV2_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","InstallHostPatchV2_Task") - kw["aname"] = "_InstallHostPatchV2_Task" - if ns0.InstallHostPatchV2RequestType_Def not in ns0.InstallHostPatchV2_Task_Dec.__bases__: - bases = list(ns0.InstallHostPatchV2_Task_Dec.__bases__) - bases.insert(0, ns0.InstallHostPatchV2RequestType_Def) - ns0.InstallHostPatchV2_Task_Dec.__bases__ = tuple(bases) - - ns0.InstallHostPatchV2RequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "InstallHostPatchV2_Task_Dec_Holder" - - class InstallHostPatchV2_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "InstallHostPatchV2_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.InstallHostPatchV2_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","InstallHostPatchV2_TaskResponse") - kw["aname"] = "_InstallHostPatchV2_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "InstallHostPatchV2_TaskResponse_Holder" - self.pyclass = Holder - - class UninstallHostPatch_Dec(ElementDeclaration): - literal = "UninstallHostPatch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UninstallHostPatch") - kw["aname"] = "_UninstallHostPatch" - if ns0.UninstallHostPatchRequestType_Def not in ns0.UninstallHostPatch_Dec.__bases__: - bases = list(ns0.UninstallHostPatch_Dec.__bases__) - bases.insert(0, ns0.UninstallHostPatchRequestType_Def) - ns0.UninstallHostPatch_Dec.__bases__ = tuple(bases) - - ns0.UninstallHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UninstallHostPatch_Dec_Holder" - - class UninstallHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UninstallHostPatchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UninstallHostPatchResponse_Dec.schema - TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UninstallHostPatchResponse") - kw["aname"] = "_UninstallHostPatchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UninstallHostPatchResponse_Holder" - self.pyclass = Holder - - class UninstallHostPatch_Task_Dec(ElementDeclaration): - literal = "UninstallHostPatch_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UninstallHostPatch_Task") - kw["aname"] = "_UninstallHostPatch_Task" - if ns0.UninstallHostPatchRequestType_Def not in ns0.UninstallHostPatch_Task_Dec.__bases__: - bases = list(ns0.UninstallHostPatch_Task_Dec.__bases__) - bases.insert(0, ns0.UninstallHostPatchRequestType_Def) - ns0.UninstallHostPatch_Task_Dec.__bases__ = tuple(bases) - - ns0.UninstallHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UninstallHostPatch_Task_Dec_Holder" - - class UninstallHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UninstallHostPatch_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UninstallHostPatch_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","UninstallHostPatch_TaskResponse") - kw["aname"] = "_UninstallHostPatch_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "UninstallHostPatch_TaskResponse_Holder" - self.pyclass = Holder - - class QueryHostPatch_Dec(ElementDeclaration): - literal = "QueryHostPatch" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryHostPatch") - kw["aname"] = "_QueryHostPatch" - if ns0.QueryHostPatchRequestType_Def not in ns0.QueryHostPatch_Dec.__bases__: - bases = list(ns0.QueryHostPatch_Dec.__bases__) - bases.insert(0, ns0.QueryHostPatchRequestType_Def) - ns0.QueryHostPatch_Dec.__bases__ = tuple(bases) - - ns0.QueryHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryHostPatch_Dec_Holder" - - class QueryHostPatchResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryHostPatchResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryHostPatchResponse_Dec.schema - TClist = [GTD("urn:vim25","HostPatchManagerResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryHostPatchResponse") - kw["aname"] = "_QueryHostPatchResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryHostPatchResponse_Holder" - self.pyclass = Holder - - class QueryHostPatch_Task_Dec(ElementDeclaration): - literal = "QueryHostPatch_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryHostPatch_Task") - kw["aname"] = "_QueryHostPatch_Task" - if ns0.QueryHostPatchRequestType_Def not in ns0.QueryHostPatch_Task_Dec.__bases__: - bases = list(ns0.QueryHostPatch_Task_Dec.__bases__) - bases.insert(0, ns0.QueryHostPatchRequestType_Def) - ns0.QueryHostPatch_Task_Dec.__bases__ = tuple(bases) - - ns0.QueryHostPatchRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryHostPatch_Task_Dec_Holder" - - class QueryHostPatch_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryHostPatch_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryHostPatch_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryHostPatch_TaskResponse") - kw["aname"] = "_QueryHostPatch_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryHostPatch_TaskResponse_Holder" - self.pyclass = Holder - - class Refresh_Dec(ElementDeclaration): - literal = "Refresh" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","Refresh") - kw["aname"] = "_Refresh" - if ns0.RefreshRequestType_Def not in ns0.Refresh_Dec.__bases__: - bases = list(ns0.Refresh_Dec.__bases__) - bases.insert(0, ns0.RefreshRequestType_Def) - ns0.Refresh_Dec.__bases__ = tuple(bases) - - ns0.RefreshRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "Refresh_Dec_Holder" - - class RefreshResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshResponse") - kw["aname"] = "_RefreshResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshResponse_Holder" - self.pyclass = Holder - - class UpdatePassthruConfig_Dec(ElementDeclaration): - literal = "UpdatePassthruConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdatePassthruConfig") - kw["aname"] = "_UpdatePassthruConfig" - if ns0.UpdatePassthruConfigRequestType_Def not in ns0.UpdatePassthruConfig_Dec.__bases__: - bases = list(ns0.UpdatePassthruConfig_Dec.__bases__) - bases.insert(0, ns0.UpdatePassthruConfigRequestType_Def) - ns0.UpdatePassthruConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdatePassthruConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdatePassthruConfig_Dec_Holder" - - class UpdatePassthruConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdatePassthruConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdatePassthruConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdatePassthruConfigResponse") - kw["aname"] = "_UpdatePassthruConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdatePassthruConfigResponse_Holder" - self.pyclass = Holder - - class UpdateServicePolicy_Dec(ElementDeclaration): - literal = "UpdateServicePolicy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateServicePolicy") - kw["aname"] = "_UpdateServicePolicy" - if ns0.UpdateServicePolicyRequestType_Def not in ns0.UpdateServicePolicy_Dec.__bases__: - bases = list(ns0.UpdateServicePolicy_Dec.__bases__) - bases.insert(0, ns0.UpdateServicePolicyRequestType_Def) - ns0.UpdateServicePolicy_Dec.__bases__ = tuple(bases) - - ns0.UpdateServicePolicyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateServicePolicy_Dec_Holder" - - class UpdateServicePolicyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateServicePolicyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateServicePolicyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateServicePolicyResponse") - kw["aname"] = "_UpdateServicePolicyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateServicePolicyResponse_Holder" - self.pyclass = Holder - - class StartService_Dec(ElementDeclaration): - literal = "StartService" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StartService") - kw["aname"] = "_StartService" - if ns0.StartServiceRequestType_Def not in ns0.StartService_Dec.__bases__: - bases = list(ns0.StartService_Dec.__bases__) - bases.insert(0, ns0.StartServiceRequestType_Def) - ns0.StartService_Dec.__bases__ = tuple(bases) - - ns0.StartServiceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StartService_Dec_Holder" - - class StartServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StartServiceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StartServiceResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","StartServiceResponse") - kw["aname"] = "_StartServiceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "StartServiceResponse_Holder" - self.pyclass = Holder - - class StopService_Dec(ElementDeclaration): - literal = "StopService" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","StopService") - kw["aname"] = "_StopService" - if ns0.StopServiceRequestType_Def not in ns0.StopService_Dec.__bases__: - bases = list(ns0.StopService_Dec.__bases__) - bases.insert(0, ns0.StopServiceRequestType_Def) - ns0.StopService_Dec.__bases__ = tuple(bases) - - ns0.StopServiceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "StopService_Dec_Holder" - - class StopServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "StopServiceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.StopServiceResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","StopServiceResponse") - kw["aname"] = "_StopServiceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "StopServiceResponse_Holder" - self.pyclass = Holder - - class RestartService_Dec(ElementDeclaration): - literal = "RestartService" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RestartService") - kw["aname"] = "_RestartService" - if ns0.RestartServiceRequestType_Def not in ns0.RestartService_Dec.__bases__: - bases = list(ns0.RestartService_Dec.__bases__) - bases.insert(0, ns0.RestartServiceRequestType_Def) - ns0.RestartService_Dec.__bases__ = tuple(bases) - - ns0.RestartServiceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RestartService_Dec_Holder" - - class RestartServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RestartServiceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RestartServiceResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RestartServiceResponse") - kw["aname"] = "_RestartServiceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RestartServiceResponse_Holder" - self.pyclass = Holder - - class UninstallService_Dec(ElementDeclaration): - literal = "UninstallService" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UninstallService") - kw["aname"] = "_UninstallService" - if ns0.UninstallServiceRequestType_Def not in ns0.UninstallService_Dec.__bases__: - bases = list(ns0.UninstallService_Dec.__bases__) - bases.insert(0, ns0.UninstallServiceRequestType_Def) - ns0.UninstallService_Dec.__bases__ = tuple(bases) - - ns0.UninstallServiceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UninstallService_Dec_Holder" - - class UninstallServiceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UninstallServiceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UninstallServiceResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UninstallServiceResponse") - kw["aname"] = "_UninstallServiceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UninstallServiceResponse_Holder" - self.pyclass = Holder - - class RefreshServices_Dec(ElementDeclaration): - literal = "RefreshServices" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshServices") - kw["aname"] = "_RefreshServices" - if ns0.RefreshServicesRequestType_Def not in ns0.RefreshServices_Dec.__bases__: - bases = list(ns0.RefreshServices_Dec.__bases__) - bases.insert(0, ns0.RefreshServicesRequestType_Def) - ns0.RefreshServices_Dec.__bases__ = tuple(bases) - - ns0.RefreshServicesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshServices_Dec_Holder" - - class RefreshServicesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshServicesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshServicesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshServicesResponse") - kw["aname"] = "_RefreshServicesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshServicesResponse_Holder" - self.pyclass = Holder - - class ReconfigureSnmpAgent_Dec(ElementDeclaration): - literal = "ReconfigureSnmpAgent" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureSnmpAgent") - kw["aname"] = "_ReconfigureSnmpAgent" - if ns0.ReconfigureSnmpAgentRequestType_Def not in ns0.ReconfigureSnmpAgent_Dec.__bases__: - bases = list(ns0.ReconfigureSnmpAgent_Dec.__bases__) - bases.insert(0, ns0.ReconfigureSnmpAgentRequestType_Def) - ns0.ReconfigureSnmpAgent_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureSnmpAgentRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureSnmpAgent_Dec_Holder" - - class ReconfigureSnmpAgentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureSnmpAgentResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureSnmpAgentResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureSnmpAgentResponse") - kw["aname"] = "_ReconfigureSnmpAgentResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureSnmpAgentResponse_Holder" - self.pyclass = Holder - - class SendTestNotification_Dec(ElementDeclaration): - literal = "SendTestNotification" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SendTestNotification") - kw["aname"] = "_SendTestNotification" - if ns0.SendTestNotificationRequestType_Def not in ns0.SendTestNotification_Dec.__bases__: - bases = list(ns0.SendTestNotification_Dec.__bases__) - bases.insert(0, ns0.SendTestNotificationRequestType_Def) - ns0.SendTestNotification_Dec.__bases__ = tuple(bases) - - ns0.SendTestNotificationRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SendTestNotification_Dec_Holder" - - class SendTestNotificationResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SendTestNotificationResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SendTestNotificationResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SendTestNotificationResponse") - kw["aname"] = "_SendTestNotificationResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SendTestNotificationResponse_Holder" - self.pyclass = Holder - - class RetrieveDiskPartitionInfo_Dec(ElementDeclaration): - literal = "RetrieveDiskPartitionInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveDiskPartitionInfo") - kw["aname"] = "_RetrieveDiskPartitionInfo" - if ns0.RetrieveDiskPartitionInfoRequestType_Def not in ns0.RetrieveDiskPartitionInfo_Dec.__bases__: - bases = list(ns0.RetrieveDiskPartitionInfo_Dec.__bases__) - bases.insert(0, ns0.RetrieveDiskPartitionInfoRequestType_Def) - ns0.RetrieveDiskPartitionInfo_Dec.__bases__ = tuple(bases) - - ns0.RetrieveDiskPartitionInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveDiskPartitionInfo_Dec_Holder" - - class RetrieveDiskPartitionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveDiskPartitionInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveDiskPartitionInfoResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveDiskPartitionInfoResponse") - kw["aname"] = "_RetrieveDiskPartitionInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveDiskPartitionInfoResponse_Holder" - self.pyclass = Holder - - class ComputeDiskPartitionInfo_Dec(ElementDeclaration): - literal = "ComputeDiskPartitionInfo" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfo") - kw["aname"] = "_ComputeDiskPartitionInfo" - if ns0.ComputeDiskPartitionInfoRequestType_Def not in ns0.ComputeDiskPartitionInfo_Dec.__bases__: - bases = list(ns0.ComputeDiskPartitionInfo_Dec.__bases__) - bases.insert(0, ns0.ComputeDiskPartitionInfoRequestType_Def) - ns0.ComputeDiskPartitionInfo_Dec.__bases__ = tuple(bases) - - ns0.ComputeDiskPartitionInfoRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ComputeDiskPartitionInfo_Dec_Holder" - - class ComputeDiskPartitionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ComputeDiskPartitionInfoResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ComputeDiskPartitionInfoResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfoResponse") - kw["aname"] = "_ComputeDiskPartitionInfoResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ComputeDiskPartitionInfoResponse_Holder" - self.pyclass = Holder - - class ComputeDiskPartitionInfoForResize_Dec(ElementDeclaration): - literal = "ComputeDiskPartitionInfoForResize" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfoForResize") - kw["aname"] = "_ComputeDiskPartitionInfoForResize" - if ns0.ComputeDiskPartitionInfoForResizeRequestType_Def not in ns0.ComputeDiskPartitionInfoForResize_Dec.__bases__: - bases = list(ns0.ComputeDiskPartitionInfoForResize_Dec.__bases__) - bases.insert(0, ns0.ComputeDiskPartitionInfoForResizeRequestType_Def) - ns0.ComputeDiskPartitionInfoForResize_Dec.__bases__ = tuple(bases) - - ns0.ComputeDiskPartitionInfoForResizeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ComputeDiskPartitionInfoForResize_Dec_Holder" - - class ComputeDiskPartitionInfoForResizeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ComputeDiskPartitionInfoForResizeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ComputeDiskPartitionInfoForResizeResponse_Dec.schema - TClist = [GTD("urn:vim25","HostDiskPartitionInfo",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ComputeDiskPartitionInfoForResizeResponse") - kw["aname"] = "_ComputeDiskPartitionInfoForResizeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ComputeDiskPartitionInfoForResizeResponse_Holder" - self.pyclass = Holder - - class UpdateDiskPartitions_Dec(ElementDeclaration): - literal = "UpdateDiskPartitions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateDiskPartitions") - kw["aname"] = "_UpdateDiskPartitions" - if ns0.UpdateDiskPartitionsRequestType_Def not in ns0.UpdateDiskPartitions_Dec.__bases__: - bases = list(ns0.UpdateDiskPartitions_Dec.__bases__) - bases.insert(0, ns0.UpdateDiskPartitionsRequestType_Def) - ns0.UpdateDiskPartitions_Dec.__bases__ = tuple(bases) - - ns0.UpdateDiskPartitionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateDiskPartitions_Dec_Holder" - - class UpdateDiskPartitionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateDiskPartitionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateDiskPartitionsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateDiskPartitionsResponse") - kw["aname"] = "_UpdateDiskPartitionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateDiskPartitionsResponse_Holder" - self.pyclass = Holder - - class FormatVmfs_Dec(ElementDeclaration): - literal = "FormatVmfs" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","FormatVmfs") - kw["aname"] = "_FormatVmfs" - if ns0.FormatVmfsRequestType_Def not in ns0.FormatVmfs_Dec.__bases__: - bases = list(ns0.FormatVmfs_Dec.__bases__) - bases.insert(0, ns0.FormatVmfsRequestType_Def) - ns0.FormatVmfs_Dec.__bases__ = tuple(bases) - - ns0.FormatVmfsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "FormatVmfs_Dec_Holder" - - class FormatVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "FormatVmfsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.FormatVmfsResponse_Dec.schema - TClist = [GTD("urn:vim25","HostVmfsVolume",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","FormatVmfsResponse") - kw["aname"] = "_FormatVmfsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "FormatVmfsResponse_Holder" - self.pyclass = Holder - - class RescanVmfs_Dec(ElementDeclaration): - literal = "RescanVmfs" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RescanVmfs") - kw["aname"] = "_RescanVmfs" - if ns0.RescanVmfsRequestType_Def not in ns0.RescanVmfs_Dec.__bases__: - bases = list(ns0.RescanVmfs_Dec.__bases__) - bases.insert(0, ns0.RescanVmfsRequestType_Def) - ns0.RescanVmfs_Dec.__bases__ = tuple(bases) - - ns0.RescanVmfsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RescanVmfs_Dec_Holder" - - class RescanVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RescanVmfsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RescanVmfsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RescanVmfsResponse") - kw["aname"] = "_RescanVmfsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RescanVmfsResponse_Holder" - self.pyclass = Holder - - class AttachVmfsExtent_Dec(ElementDeclaration): - literal = "AttachVmfsExtent" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AttachVmfsExtent") - kw["aname"] = "_AttachVmfsExtent" - if ns0.AttachVmfsExtentRequestType_Def not in ns0.AttachVmfsExtent_Dec.__bases__: - bases = list(ns0.AttachVmfsExtent_Dec.__bases__) - bases.insert(0, ns0.AttachVmfsExtentRequestType_Def) - ns0.AttachVmfsExtent_Dec.__bases__ = tuple(bases) - - ns0.AttachVmfsExtentRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AttachVmfsExtent_Dec_Holder" - - class AttachVmfsExtentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AttachVmfsExtentResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AttachVmfsExtentResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AttachVmfsExtentResponse") - kw["aname"] = "_AttachVmfsExtentResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AttachVmfsExtentResponse_Holder" - self.pyclass = Holder - - class ExpandVmfsExtent_Dec(ElementDeclaration): - literal = "ExpandVmfsExtent" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ExpandVmfsExtent") - kw["aname"] = "_ExpandVmfsExtent" - if ns0.ExpandVmfsExtentRequestType_Def not in ns0.ExpandVmfsExtent_Dec.__bases__: - bases = list(ns0.ExpandVmfsExtent_Dec.__bases__) - bases.insert(0, ns0.ExpandVmfsExtentRequestType_Def) - ns0.ExpandVmfsExtent_Dec.__bases__ = tuple(bases) - - ns0.ExpandVmfsExtentRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ExpandVmfsExtent_Dec_Holder" - - class ExpandVmfsExtentResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ExpandVmfsExtentResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ExpandVmfsExtentResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ExpandVmfsExtentResponse") - kw["aname"] = "_ExpandVmfsExtentResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ExpandVmfsExtentResponse_Holder" - self.pyclass = Holder - - class UpgradeVmfs_Dec(ElementDeclaration): - literal = "UpgradeVmfs" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpgradeVmfs") - kw["aname"] = "_UpgradeVmfs" - if ns0.UpgradeVmfsRequestType_Def not in ns0.UpgradeVmfs_Dec.__bases__: - bases = list(ns0.UpgradeVmfs_Dec.__bases__) - bases.insert(0, ns0.UpgradeVmfsRequestType_Def) - ns0.UpgradeVmfs_Dec.__bases__ = tuple(bases) - - ns0.UpgradeVmfsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVmfs_Dec_Holder" - - class UpgradeVmfsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpgradeVmfsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpgradeVmfsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpgradeVmfsResponse") - kw["aname"] = "_UpgradeVmfsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpgradeVmfsResponse_Holder" - self.pyclass = Holder - - class UpgradeVmLayout_Dec(ElementDeclaration): - literal = "UpgradeVmLayout" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpgradeVmLayout") - kw["aname"] = "_UpgradeVmLayout" - if ns0.UpgradeVmLayoutRequestType_Def not in ns0.UpgradeVmLayout_Dec.__bases__: - bases = list(ns0.UpgradeVmLayout_Dec.__bases__) - bases.insert(0, ns0.UpgradeVmLayoutRequestType_Def) - ns0.UpgradeVmLayout_Dec.__bases__ = tuple(bases) - - ns0.UpgradeVmLayoutRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpgradeVmLayout_Dec_Holder" - - class UpgradeVmLayoutResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpgradeVmLayoutResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpgradeVmLayoutResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpgradeVmLayoutResponse") - kw["aname"] = "_UpgradeVmLayoutResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpgradeVmLayoutResponse_Holder" - self.pyclass = Holder - - class QueryUnresolvedVmfsVolume_Dec(ElementDeclaration): - literal = "QueryUnresolvedVmfsVolume" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolume") - kw["aname"] = "_QueryUnresolvedVmfsVolume" - if ns0.QueryUnresolvedVmfsVolumeRequestType_Def not in ns0.QueryUnresolvedVmfsVolume_Dec.__bases__: - bases = list(ns0.QueryUnresolvedVmfsVolume_Dec.__bases__) - bases.insert(0, ns0.QueryUnresolvedVmfsVolumeRequestType_Def) - ns0.QueryUnresolvedVmfsVolume_Dec.__bases__ = tuple(bases) - - ns0.QueryUnresolvedVmfsVolumeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryUnresolvedVmfsVolume_Dec_Holder" - - class QueryUnresolvedVmfsVolumeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryUnresolvedVmfsVolumeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryUnresolvedVmfsVolumeResponse_Dec.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsVolume",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryUnresolvedVmfsVolumeResponse") - kw["aname"] = "_QueryUnresolvedVmfsVolumeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryUnresolvedVmfsVolumeResponse_Holder" - self.pyclass = Holder - - class ResolveMultipleUnresolvedVmfsVolumes_Dec(ElementDeclaration): - literal = "ResolveMultipleUnresolvedVmfsVolumes" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResolveMultipleUnresolvedVmfsVolumes") - kw["aname"] = "_ResolveMultipleUnresolvedVmfsVolumes" - if ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def not in ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec.__bases__: - bases = list(ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec.__bases__) - bases.insert(0, ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def) - ns0.ResolveMultipleUnresolvedVmfsVolumes_Dec.__bases__ = tuple(bases) - - ns0.ResolveMultipleUnresolvedVmfsVolumesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResolveMultipleUnresolvedVmfsVolumes_Dec_Holder" - - class ResolveMultipleUnresolvedVmfsVolumesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResolveMultipleUnresolvedVmfsVolumesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResolveMultipleUnresolvedVmfsVolumesResponse_Dec.schema - TClist = [GTD("urn:vim25","HostUnresolvedVmfsResolutionResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ResolveMultipleUnresolvedVmfsVolumesResponse") - kw["aname"] = "_ResolveMultipleUnresolvedVmfsVolumesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ResolveMultipleUnresolvedVmfsVolumesResponse_Holder" - self.pyclass = Holder - - class UnmountForceMountedVmfsVolume_Dec(ElementDeclaration): - literal = "UnmountForceMountedVmfsVolume" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UnmountForceMountedVmfsVolume") - kw["aname"] = "_UnmountForceMountedVmfsVolume" - if ns0.UnmountForceMountedVmfsVolumeRequestType_Def not in ns0.UnmountForceMountedVmfsVolume_Dec.__bases__: - bases = list(ns0.UnmountForceMountedVmfsVolume_Dec.__bases__) - bases.insert(0, ns0.UnmountForceMountedVmfsVolumeRequestType_Def) - ns0.UnmountForceMountedVmfsVolume_Dec.__bases__ = tuple(bases) - - ns0.UnmountForceMountedVmfsVolumeRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UnmountForceMountedVmfsVolume_Dec_Holder" - - class UnmountForceMountedVmfsVolumeResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UnmountForceMountedVmfsVolumeResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UnmountForceMountedVmfsVolumeResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UnmountForceMountedVmfsVolumeResponse") - kw["aname"] = "_UnmountForceMountedVmfsVolumeResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UnmountForceMountedVmfsVolumeResponse_Holder" - self.pyclass = Holder - - class RescanHba_Dec(ElementDeclaration): - literal = "RescanHba" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RescanHba") - kw["aname"] = "_RescanHba" - if ns0.RescanHbaRequestType_Def not in ns0.RescanHba_Dec.__bases__: - bases = list(ns0.RescanHba_Dec.__bases__) - bases.insert(0, ns0.RescanHbaRequestType_Def) - ns0.RescanHba_Dec.__bases__ = tuple(bases) - - ns0.RescanHbaRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RescanHba_Dec_Holder" - - class RescanHbaResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RescanHbaResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RescanHbaResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RescanHbaResponse") - kw["aname"] = "_RescanHbaResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RescanHbaResponse_Holder" - self.pyclass = Holder - - class RescanAllHba_Dec(ElementDeclaration): - literal = "RescanAllHba" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RescanAllHba") - kw["aname"] = "_RescanAllHba" - if ns0.RescanAllHbaRequestType_Def not in ns0.RescanAllHba_Dec.__bases__: - bases = list(ns0.RescanAllHba_Dec.__bases__) - bases.insert(0, ns0.RescanAllHbaRequestType_Def) - ns0.RescanAllHba_Dec.__bases__ = tuple(bases) - - ns0.RescanAllHbaRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RescanAllHba_Dec_Holder" - - class RescanAllHbaResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RescanAllHbaResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RescanAllHbaResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RescanAllHbaResponse") - kw["aname"] = "_RescanAllHbaResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RescanAllHbaResponse_Holder" - self.pyclass = Holder - - class UpdateSoftwareInternetScsiEnabled_Dec(ElementDeclaration): - literal = "UpdateSoftwareInternetScsiEnabled" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateSoftwareInternetScsiEnabled") - kw["aname"] = "_UpdateSoftwareInternetScsiEnabled" - if ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def not in ns0.UpdateSoftwareInternetScsiEnabled_Dec.__bases__: - bases = list(ns0.UpdateSoftwareInternetScsiEnabled_Dec.__bases__) - bases.insert(0, ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def) - ns0.UpdateSoftwareInternetScsiEnabled_Dec.__bases__ = tuple(bases) - - ns0.UpdateSoftwareInternetScsiEnabledRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateSoftwareInternetScsiEnabled_Dec_Holder" - - class UpdateSoftwareInternetScsiEnabledResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateSoftwareInternetScsiEnabledResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateSoftwareInternetScsiEnabledResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateSoftwareInternetScsiEnabledResponse") - kw["aname"] = "_UpdateSoftwareInternetScsiEnabledResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateSoftwareInternetScsiEnabledResponse_Holder" - self.pyclass = Holder - - class UpdateInternetScsiDiscoveryProperties_Dec(ElementDeclaration): - literal = "UpdateInternetScsiDiscoveryProperties" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateInternetScsiDiscoveryProperties") - kw["aname"] = "_UpdateInternetScsiDiscoveryProperties" - if ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def not in ns0.UpdateInternetScsiDiscoveryProperties_Dec.__bases__: - bases = list(ns0.UpdateInternetScsiDiscoveryProperties_Dec.__bases__) - bases.insert(0, ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def) - ns0.UpdateInternetScsiDiscoveryProperties_Dec.__bases__ = tuple(bases) - - ns0.UpdateInternetScsiDiscoveryPropertiesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiDiscoveryProperties_Dec_Holder" - - class UpdateInternetScsiDiscoveryPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateInternetScsiDiscoveryPropertiesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateInternetScsiDiscoveryPropertiesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateInternetScsiDiscoveryPropertiesResponse") - kw["aname"] = "_UpdateInternetScsiDiscoveryPropertiesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateInternetScsiDiscoveryPropertiesResponse_Holder" - self.pyclass = Holder - - class UpdateInternetScsiAuthenticationProperties_Dec(ElementDeclaration): - literal = "UpdateInternetScsiAuthenticationProperties" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateInternetScsiAuthenticationProperties") - kw["aname"] = "_UpdateInternetScsiAuthenticationProperties" - if ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def not in ns0.UpdateInternetScsiAuthenticationProperties_Dec.__bases__: - bases = list(ns0.UpdateInternetScsiAuthenticationProperties_Dec.__bases__) - bases.insert(0, ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def) - ns0.UpdateInternetScsiAuthenticationProperties_Dec.__bases__ = tuple(bases) - - ns0.UpdateInternetScsiAuthenticationPropertiesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiAuthenticationProperties_Dec_Holder" - - class UpdateInternetScsiAuthenticationPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateInternetScsiAuthenticationPropertiesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateInternetScsiAuthenticationPropertiesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateInternetScsiAuthenticationPropertiesResponse") - kw["aname"] = "_UpdateInternetScsiAuthenticationPropertiesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateInternetScsiAuthenticationPropertiesResponse_Holder" - self.pyclass = Holder - - class UpdateInternetScsiDigestProperties_Dec(ElementDeclaration): - literal = "UpdateInternetScsiDigestProperties" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateInternetScsiDigestProperties") - kw["aname"] = "_UpdateInternetScsiDigestProperties" - if ns0.UpdateInternetScsiDigestPropertiesRequestType_Def not in ns0.UpdateInternetScsiDigestProperties_Dec.__bases__: - bases = list(ns0.UpdateInternetScsiDigestProperties_Dec.__bases__) - bases.insert(0, ns0.UpdateInternetScsiDigestPropertiesRequestType_Def) - ns0.UpdateInternetScsiDigestProperties_Dec.__bases__ = tuple(bases) - - ns0.UpdateInternetScsiDigestPropertiesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiDigestProperties_Dec_Holder" - - class UpdateInternetScsiDigestPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateInternetScsiDigestPropertiesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateInternetScsiDigestPropertiesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateInternetScsiDigestPropertiesResponse") - kw["aname"] = "_UpdateInternetScsiDigestPropertiesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateInternetScsiDigestPropertiesResponse_Holder" - self.pyclass = Holder - - class UpdateInternetScsiAdvancedOptions_Dec(ElementDeclaration): - literal = "UpdateInternetScsiAdvancedOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateInternetScsiAdvancedOptions") - kw["aname"] = "_UpdateInternetScsiAdvancedOptions" - if ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def not in ns0.UpdateInternetScsiAdvancedOptions_Dec.__bases__: - bases = list(ns0.UpdateInternetScsiAdvancedOptions_Dec.__bases__) - bases.insert(0, ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def) - ns0.UpdateInternetScsiAdvancedOptions_Dec.__bases__ = tuple(bases) - - ns0.UpdateInternetScsiAdvancedOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiAdvancedOptions_Dec_Holder" - - class UpdateInternetScsiAdvancedOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateInternetScsiAdvancedOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateInternetScsiAdvancedOptionsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateInternetScsiAdvancedOptionsResponse") - kw["aname"] = "_UpdateInternetScsiAdvancedOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateInternetScsiAdvancedOptionsResponse_Holder" - self.pyclass = Holder - - class UpdateInternetScsiIPProperties_Dec(ElementDeclaration): - literal = "UpdateInternetScsiIPProperties" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateInternetScsiIPProperties") - kw["aname"] = "_UpdateInternetScsiIPProperties" - if ns0.UpdateInternetScsiIPPropertiesRequestType_Def not in ns0.UpdateInternetScsiIPProperties_Dec.__bases__: - bases = list(ns0.UpdateInternetScsiIPProperties_Dec.__bases__) - bases.insert(0, ns0.UpdateInternetScsiIPPropertiesRequestType_Def) - ns0.UpdateInternetScsiIPProperties_Dec.__bases__ = tuple(bases) - - ns0.UpdateInternetScsiIPPropertiesRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiIPProperties_Dec_Holder" - - class UpdateInternetScsiIPPropertiesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateInternetScsiIPPropertiesResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateInternetScsiIPPropertiesResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateInternetScsiIPPropertiesResponse") - kw["aname"] = "_UpdateInternetScsiIPPropertiesResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateInternetScsiIPPropertiesResponse_Holder" - self.pyclass = Holder - - class UpdateInternetScsiName_Dec(ElementDeclaration): - literal = "UpdateInternetScsiName" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateInternetScsiName") - kw["aname"] = "_UpdateInternetScsiName" - if ns0.UpdateInternetScsiNameRequestType_Def not in ns0.UpdateInternetScsiName_Dec.__bases__: - bases = list(ns0.UpdateInternetScsiName_Dec.__bases__) - bases.insert(0, ns0.UpdateInternetScsiNameRequestType_Def) - ns0.UpdateInternetScsiName_Dec.__bases__ = tuple(bases) - - ns0.UpdateInternetScsiNameRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiName_Dec_Holder" - - class UpdateInternetScsiNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateInternetScsiNameResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateInternetScsiNameResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateInternetScsiNameResponse") - kw["aname"] = "_UpdateInternetScsiNameResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateInternetScsiNameResponse_Holder" - self.pyclass = Holder - - class UpdateInternetScsiAlias_Dec(ElementDeclaration): - literal = "UpdateInternetScsiAlias" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateInternetScsiAlias") - kw["aname"] = "_UpdateInternetScsiAlias" - if ns0.UpdateInternetScsiAliasRequestType_Def not in ns0.UpdateInternetScsiAlias_Dec.__bases__: - bases = list(ns0.UpdateInternetScsiAlias_Dec.__bases__) - bases.insert(0, ns0.UpdateInternetScsiAliasRequestType_Def) - ns0.UpdateInternetScsiAlias_Dec.__bases__ = tuple(bases) - - ns0.UpdateInternetScsiAliasRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateInternetScsiAlias_Dec_Holder" - - class UpdateInternetScsiAliasResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateInternetScsiAliasResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateInternetScsiAliasResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateInternetScsiAliasResponse") - kw["aname"] = "_UpdateInternetScsiAliasResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateInternetScsiAliasResponse_Holder" - self.pyclass = Holder - - class AddInternetScsiSendTargets_Dec(ElementDeclaration): - literal = "AddInternetScsiSendTargets" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddInternetScsiSendTargets") - kw["aname"] = "_AddInternetScsiSendTargets" - if ns0.AddInternetScsiSendTargetsRequestType_Def not in ns0.AddInternetScsiSendTargets_Dec.__bases__: - bases = list(ns0.AddInternetScsiSendTargets_Dec.__bases__) - bases.insert(0, ns0.AddInternetScsiSendTargetsRequestType_Def) - ns0.AddInternetScsiSendTargets_Dec.__bases__ = tuple(bases) - - ns0.AddInternetScsiSendTargetsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddInternetScsiSendTargets_Dec_Holder" - - class AddInternetScsiSendTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddInternetScsiSendTargetsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddInternetScsiSendTargetsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AddInternetScsiSendTargetsResponse") - kw["aname"] = "_AddInternetScsiSendTargetsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AddInternetScsiSendTargetsResponse_Holder" - self.pyclass = Holder - - class RemoveInternetScsiSendTargets_Dec(ElementDeclaration): - literal = "RemoveInternetScsiSendTargets" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveInternetScsiSendTargets") - kw["aname"] = "_RemoveInternetScsiSendTargets" - if ns0.RemoveInternetScsiSendTargetsRequestType_Def not in ns0.RemoveInternetScsiSendTargets_Dec.__bases__: - bases = list(ns0.RemoveInternetScsiSendTargets_Dec.__bases__) - bases.insert(0, ns0.RemoveInternetScsiSendTargetsRequestType_Def) - ns0.RemoveInternetScsiSendTargets_Dec.__bases__ = tuple(bases) - - ns0.RemoveInternetScsiSendTargetsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveInternetScsiSendTargets_Dec_Holder" - - class RemoveInternetScsiSendTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveInternetScsiSendTargetsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveInternetScsiSendTargetsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveInternetScsiSendTargetsResponse") - kw["aname"] = "_RemoveInternetScsiSendTargetsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveInternetScsiSendTargetsResponse_Holder" - self.pyclass = Holder - - class AddInternetScsiStaticTargets_Dec(ElementDeclaration): - literal = "AddInternetScsiStaticTargets" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","AddInternetScsiStaticTargets") - kw["aname"] = "_AddInternetScsiStaticTargets" - if ns0.AddInternetScsiStaticTargetsRequestType_Def not in ns0.AddInternetScsiStaticTargets_Dec.__bases__: - bases = list(ns0.AddInternetScsiStaticTargets_Dec.__bases__) - bases.insert(0, ns0.AddInternetScsiStaticTargetsRequestType_Def) - ns0.AddInternetScsiStaticTargets_Dec.__bases__ = tuple(bases) - - ns0.AddInternetScsiStaticTargetsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "AddInternetScsiStaticTargets_Dec_Holder" - - class AddInternetScsiStaticTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "AddInternetScsiStaticTargetsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.AddInternetScsiStaticTargetsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","AddInternetScsiStaticTargetsResponse") - kw["aname"] = "_AddInternetScsiStaticTargetsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "AddInternetScsiStaticTargetsResponse_Holder" - self.pyclass = Holder - - class RemoveInternetScsiStaticTargets_Dec(ElementDeclaration): - literal = "RemoveInternetScsiStaticTargets" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveInternetScsiStaticTargets") - kw["aname"] = "_RemoveInternetScsiStaticTargets" - if ns0.RemoveInternetScsiStaticTargetsRequestType_Def not in ns0.RemoveInternetScsiStaticTargets_Dec.__bases__: - bases = list(ns0.RemoveInternetScsiStaticTargets_Dec.__bases__) - bases.insert(0, ns0.RemoveInternetScsiStaticTargetsRequestType_Def) - ns0.RemoveInternetScsiStaticTargets_Dec.__bases__ = tuple(bases) - - ns0.RemoveInternetScsiStaticTargetsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveInternetScsiStaticTargets_Dec_Holder" - - class RemoveInternetScsiStaticTargetsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveInternetScsiStaticTargetsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveInternetScsiStaticTargetsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveInternetScsiStaticTargetsResponse") - kw["aname"] = "_RemoveInternetScsiStaticTargetsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveInternetScsiStaticTargetsResponse_Holder" - self.pyclass = Holder - - class EnableMultipathPath_Dec(ElementDeclaration): - literal = "EnableMultipathPath" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","EnableMultipathPath") - kw["aname"] = "_EnableMultipathPath" - if ns0.EnableMultipathPathRequestType_Def not in ns0.EnableMultipathPath_Dec.__bases__: - bases = list(ns0.EnableMultipathPath_Dec.__bases__) - bases.insert(0, ns0.EnableMultipathPathRequestType_Def) - ns0.EnableMultipathPath_Dec.__bases__ = tuple(bases) - - ns0.EnableMultipathPathRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "EnableMultipathPath_Dec_Holder" - - class EnableMultipathPathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "EnableMultipathPathResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.EnableMultipathPathResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","EnableMultipathPathResponse") - kw["aname"] = "_EnableMultipathPathResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "EnableMultipathPathResponse_Holder" - self.pyclass = Holder - - class DisableMultipathPath_Dec(ElementDeclaration): - literal = "DisableMultipathPath" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DisableMultipathPath") - kw["aname"] = "_DisableMultipathPath" - if ns0.DisableMultipathPathRequestType_Def not in ns0.DisableMultipathPath_Dec.__bases__: - bases = list(ns0.DisableMultipathPath_Dec.__bases__) - bases.insert(0, ns0.DisableMultipathPathRequestType_Def) - ns0.DisableMultipathPath_Dec.__bases__ = tuple(bases) - - ns0.DisableMultipathPathRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DisableMultipathPath_Dec_Holder" - - class DisableMultipathPathResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DisableMultipathPathResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DisableMultipathPathResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DisableMultipathPathResponse") - kw["aname"] = "_DisableMultipathPathResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DisableMultipathPathResponse_Holder" - self.pyclass = Holder - - class SetMultipathLunPolicy_Dec(ElementDeclaration): - literal = "SetMultipathLunPolicy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SetMultipathLunPolicy") - kw["aname"] = "_SetMultipathLunPolicy" - if ns0.SetMultipathLunPolicyRequestType_Def not in ns0.SetMultipathLunPolicy_Dec.__bases__: - bases = list(ns0.SetMultipathLunPolicy_Dec.__bases__) - bases.insert(0, ns0.SetMultipathLunPolicyRequestType_Def) - ns0.SetMultipathLunPolicy_Dec.__bases__ = tuple(bases) - - ns0.SetMultipathLunPolicyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SetMultipathLunPolicy_Dec_Holder" - - class SetMultipathLunPolicyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SetMultipathLunPolicyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SetMultipathLunPolicyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SetMultipathLunPolicyResponse") - kw["aname"] = "_SetMultipathLunPolicyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SetMultipathLunPolicyResponse_Holder" - self.pyclass = Holder - - class QueryPathSelectionPolicyOptions_Dec(ElementDeclaration): - literal = "QueryPathSelectionPolicyOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryPathSelectionPolicyOptions") - kw["aname"] = "_QueryPathSelectionPolicyOptions" - if ns0.QueryPathSelectionPolicyOptionsRequestType_Def not in ns0.QueryPathSelectionPolicyOptions_Dec.__bases__: - bases = list(ns0.QueryPathSelectionPolicyOptions_Dec.__bases__) - bases.insert(0, ns0.QueryPathSelectionPolicyOptionsRequestType_Def) - ns0.QueryPathSelectionPolicyOptions_Dec.__bases__ = tuple(bases) - - ns0.QueryPathSelectionPolicyOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryPathSelectionPolicyOptions_Dec_Holder" - - class QueryPathSelectionPolicyOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryPathSelectionPolicyOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryPathSelectionPolicyOptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","HostPathSelectionPolicyOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryPathSelectionPolicyOptionsResponse") - kw["aname"] = "_QueryPathSelectionPolicyOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryPathSelectionPolicyOptionsResponse_Holder" - self.pyclass = Holder - - class QueryStorageArrayTypePolicyOptions_Dec(ElementDeclaration): - literal = "QueryStorageArrayTypePolicyOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryStorageArrayTypePolicyOptions") - kw["aname"] = "_QueryStorageArrayTypePolicyOptions" - if ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def not in ns0.QueryStorageArrayTypePolicyOptions_Dec.__bases__: - bases = list(ns0.QueryStorageArrayTypePolicyOptions_Dec.__bases__) - bases.insert(0, ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def) - ns0.QueryStorageArrayTypePolicyOptions_Dec.__bases__ = tuple(bases) - - ns0.QueryStorageArrayTypePolicyOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryStorageArrayTypePolicyOptions_Dec_Holder" - - class QueryStorageArrayTypePolicyOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryStorageArrayTypePolicyOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryStorageArrayTypePolicyOptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","HostStorageArrayTypePolicyOption",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryStorageArrayTypePolicyOptionsResponse") - kw["aname"] = "_QueryStorageArrayTypePolicyOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryStorageArrayTypePolicyOptionsResponse_Holder" - self.pyclass = Holder - - class UpdateScsiLunDisplayName_Dec(ElementDeclaration): - literal = "UpdateScsiLunDisplayName" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateScsiLunDisplayName") - kw["aname"] = "_UpdateScsiLunDisplayName" - if ns0.UpdateScsiLunDisplayNameRequestType_Def not in ns0.UpdateScsiLunDisplayName_Dec.__bases__: - bases = list(ns0.UpdateScsiLunDisplayName_Dec.__bases__) - bases.insert(0, ns0.UpdateScsiLunDisplayNameRequestType_Def) - ns0.UpdateScsiLunDisplayName_Dec.__bases__ = tuple(bases) - - ns0.UpdateScsiLunDisplayNameRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateScsiLunDisplayName_Dec_Holder" - - class UpdateScsiLunDisplayNameResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateScsiLunDisplayNameResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateScsiLunDisplayNameResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateScsiLunDisplayNameResponse") - kw["aname"] = "_UpdateScsiLunDisplayNameResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateScsiLunDisplayNameResponse_Holder" - self.pyclass = Holder - - class RefreshStorageSystem_Dec(ElementDeclaration): - literal = "RefreshStorageSystem" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RefreshStorageSystem") - kw["aname"] = "_RefreshStorageSystem" - if ns0.RefreshStorageSystemRequestType_Def not in ns0.RefreshStorageSystem_Dec.__bases__: - bases = list(ns0.RefreshStorageSystem_Dec.__bases__) - bases.insert(0, ns0.RefreshStorageSystemRequestType_Def) - ns0.RefreshStorageSystem_Dec.__bases__ = tuple(bases) - - ns0.RefreshStorageSystemRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RefreshStorageSystem_Dec_Holder" - - class RefreshStorageSystemResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RefreshStorageSystemResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RefreshStorageSystemResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RefreshStorageSystemResponse") - kw["aname"] = "_RefreshStorageSystemResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RefreshStorageSystemResponse_Holder" - self.pyclass = Holder - - class UpdateIpConfig_Dec(ElementDeclaration): - literal = "UpdateIpConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateIpConfig") - kw["aname"] = "_UpdateIpConfig" - if ns0.UpdateIpConfigRequestType_Def not in ns0.UpdateIpConfig_Dec.__bases__: - bases = list(ns0.UpdateIpConfig_Dec.__bases__) - bases.insert(0, ns0.UpdateIpConfigRequestType_Def) - ns0.UpdateIpConfig_Dec.__bases__ = tuple(bases) - - ns0.UpdateIpConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateIpConfig_Dec_Holder" - - class UpdateIpConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateIpConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateIpConfigResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateIpConfigResponse") - kw["aname"] = "_UpdateIpConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateIpConfigResponse_Holder" - self.pyclass = Holder - - class SelectVnic_Dec(ElementDeclaration): - literal = "SelectVnic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","SelectVnic") - kw["aname"] = "_SelectVnic" - if ns0.SelectVnicRequestType_Def not in ns0.SelectVnic_Dec.__bases__: - bases = list(ns0.SelectVnic_Dec.__bases__) - bases.insert(0, ns0.SelectVnicRequestType_Def) - ns0.SelectVnic_Dec.__bases__ = tuple(bases) - - ns0.SelectVnicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "SelectVnic_Dec_Holder" - - class SelectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "SelectVnicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.SelectVnicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","SelectVnicResponse") - kw["aname"] = "_SelectVnicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "SelectVnicResponse_Holder" - self.pyclass = Holder - - class DeselectVnic_Dec(ElementDeclaration): - literal = "DeselectVnic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DeselectVnic") - kw["aname"] = "_DeselectVnic" - if ns0.DeselectVnicRequestType_Def not in ns0.DeselectVnic_Dec.__bases__: - bases = list(ns0.DeselectVnic_Dec.__bases__) - bases.insert(0, ns0.DeselectVnicRequestType_Def) - ns0.DeselectVnic_Dec.__bases__ = tuple(bases) - - ns0.DeselectVnicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DeselectVnic_Dec_Holder" - - class DeselectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DeselectVnicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DeselectVnicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DeselectVnicResponse") - kw["aname"] = "_DeselectVnicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DeselectVnicResponse_Holder" - self.pyclass = Holder - - class QueryNetConfig_Dec(ElementDeclaration): - literal = "QueryNetConfig" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryNetConfig") - kw["aname"] = "_QueryNetConfig" - if ns0.QueryNetConfigRequestType_Def not in ns0.QueryNetConfig_Dec.__bases__: - bases = list(ns0.QueryNetConfig_Dec.__bases__) - bases.insert(0, ns0.QueryNetConfigRequestType_Def) - ns0.QueryNetConfig_Dec.__bases__ = tuple(bases) - - ns0.QueryNetConfigRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryNetConfig_Dec_Holder" - - class QueryNetConfigResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryNetConfigResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryNetConfigResponse_Dec.schema - TClist = [GTD("urn:vim25","VirtualNicManagerNetConfig",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryNetConfigResponse") - kw["aname"] = "_QueryNetConfigResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryNetConfigResponse_Holder" - self.pyclass = Holder - - class VirtualNicManagerSelectVnic_Dec(ElementDeclaration): - literal = "VirtualNicManagerSelectVnic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VirtualNicManagerSelectVnic") - kw["aname"] = "_VirtualNicManagerSelectVnic" - if ns0.VirtualNicManagerSelectVnicRequestType_Def not in ns0.VirtualNicManagerSelectVnic_Dec.__bases__: - bases = list(ns0.VirtualNicManagerSelectVnic_Dec.__bases__) - bases.insert(0, ns0.VirtualNicManagerSelectVnicRequestType_Def) - ns0.VirtualNicManagerSelectVnic_Dec.__bases__ = tuple(bases) - - ns0.VirtualNicManagerSelectVnicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VirtualNicManagerSelectVnic_Dec_Holder" - - class VirtualNicManagerSelectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "VirtualNicManagerSelectVnicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.VirtualNicManagerSelectVnicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","VirtualNicManagerSelectVnicResponse") - kw["aname"] = "_VirtualNicManagerSelectVnicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "VirtualNicManagerSelectVnicResponse_Holder" - self.pyclass = Holder - - class VirtualNicManagerDeselectVnic_Dec(ElementDeclaration): - literal = "VirtualNicManagerDeselectVnic" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","VirtualNicManagerDeselectVnic") - kw["aname"] = "_VirtualNicManagerDeselectVnic" - if ns0.VirtualNicManagerDeselectVnicRequestType_Def not in ns0.VirtualNicManagerDeselectVnic_Dec.__bases__: - bases = list(ns0.VirtualNicManagerDeselectVnic_Dec.__bases__) - bases.insert(0, ns0.VirtualNicManagerDeselectVnicRequestType_Def) - ns0.VirtualNicManagerDeselectVnic_Dec.__bases__ = tuple(bases) - - ns0.VirtualNicManagerDeselectVnicRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "VirtualNicManagerDeselectVnic_Dec_Holder" - - class VirtualNicManagerDeselectVnicResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "VirtualNicManagerDeselectVnicResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.VirtualNicManagerDeselectVnicResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","VirtualNicManagerDeselectVnicResponse") - kw["aname"] = "_VirtualNicManagerDeselectVnicResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "VirtualNicManagerDeselectVnicResponse_Holder" - self.pyclass = Holder - - class QueryOptions_Dec(ElementDeclaration): - literal = "QueryOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryOptions") - kw["aname"] = "_QueryOptions" - if ns0.QueryOptionsRequestType_Def not in ns0.QueryOptions_Dec.__bases__: - bases = list(ns0.QueryOptions_Dec.__bases__) - bases.insert(0, ns0.QueryOptionsRequestType_Def) - ns0.QueryOptions_Dec.__bases__ = tuple(bases) - - ns0.QueryOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryOptions_Dec_Holder" - - class QueryOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryOptionsResponse_Dec.schema - TClist = [GTD("urn:vim25","OptionValue",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryOptionsResponse") - kw["aname"] = "_QueryOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryOptionsResponse_Holder" - self.pyclass = Holder - - class UpdateOptions_Dec(ElementDeclaration): - literal = "UpdateOptions" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","UpdateOptions") - kw["aname"] = "_UpdateOptions" - if ns0.UpdateOptionsRequestType_Def not in ns0.UpdateOptions_Dec.__bases__: - bases = list(ns0.UpdateOptions_Dec.__bases__) - bases.insert(0, ns0.UpdateOptionsRequestType_Def) - ns0.UpdateOptions_Dec.__bases__ = tuple(bases) - - ns0.UpdateOptionsRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "UpdateOptions_Dec_Holder" - - class UpdateOptionsResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "UpdateOptionsResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.UpdateOptionsResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","UpdateOptionsResponse") - kw["aname"] = "_UpdateOptionsResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "UpdateOptionsResponse_Holder" - self.pyclass = Holder - - class ComplianceManagerCheckCompliance_Dec(ElementDeclaration): - literal = "ComplianceManagerCheckCompliance" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ComplianceManagerCheckCompliance") - kw["aname"] = "_ComplianceManagerCheckCompliance" - if ns0.ComplianceManagerCheckComplianceRequestType_Def not in ns0.ComplianceManagerCheckCompliance_Dec.__bases__: - bases = list(ns0.ComplianceManagerCheckCompliance_Dec.__bases__) - bases.insert(0, ns0.ComplianceManagerCheckComplianceRequestType_Def) - ns0.ComplianceManagerCheckCompliance_Dec.__bases__ = tuple(bases) - - ns0.ComplianceManagerCheckComplianceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerCheckCompliance_Dec_Holder" - - class ComplianceManagerCheckComplianceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ComplianceManagerCheckComplianceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ComplianceManagerCheckComplianceResponse_Dec.schema - TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ComplianceManagerCheckComplianceResponse") - kw["aname"] = "_ComplianceManagerCheckComplianceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ComplianceManagerCheckComplianceResponse_Holder" - self.pyclass = Holder - - class ComplianceManagerCheckCompliance_Task_Dec(ElementDeclaration): - literal = "ComplianceManagerCheckCompliance_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ComplianceManagerCheckCompliance_Task") - kw["aname"] = "_ComplianceManagerCheckCompliance_Task" - if ns0.ComplianceManagerCheckComplianceRequestType_Def not in ns0.ComplianceManagerCheckCompliance_Task_Dec.__bases__: - bases = list(ns0.ComplianceManagerCheckCompliance_Task_Dec.__bases__) - bases.insert(0, ns0.ComplianceManagerCheckComplianceRequestType_Def) - ns0.ComplianceManagerCheckCompliance_Task_Dec.__bases__ = tuple(bases) - - ns0.ComplianceManagerCheckComplianceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerCheckCompliance_Task_Dec_Holder" - - class ComplianceManagerCheckCompliance_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ComplianceManagerCheckCompliance_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ComplianceManagerCheckCompliance_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ComplianceManagerCheckCompliance_TaskResponse") - kw["aname"] = "_ComplianceManagerCheckCompliance_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ComplianceManagerCheckCompliance_TaskResponse_Holder" - self.pyclass = Holder - - class ComplianceManagerQueryComplianceStatus_Dec(ElementDeclaration): - literal = "ComplianceManagerQueryComplianceStatus" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ComplianceManagerQueryComplianceStatus") - kw["aname"] = "_ComplianceManagerQueryComplianceStatus" - if ns0.ComplianceManagerQueryComplianceStatusRequestType_Def not in ns0.ComplianceManagerQueryComplianceStatus_Dec.__bases__: - bases = list(ns0.ComplianceManagerQueryComplianceStatus_Dec.__bases__) - bases.insert(0, ns0.ComplianceManagerQueryComplianceStatusRequestType_Def) - ns0.ComplianceManagerQueryComplianceStatus_Dec.__bases__ = tuple(bases) - - ns0.ComplianceManagerQueryComplianceStatusRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerQueryComplianceStatus_Dec_Holder" - - class ComplianceManagerQueryComplianceStatusResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ComplianceManagerQueryComplianceStatusResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ComplianceManagerQueryComplianceStatusResponse_Dec.schema - TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ComplianceManagerQueryComplianceStatusResponse") - kw["aname"] = "_ComplianceManagerQueryComplianceStatusResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ComplianceManagerQueryComplianceStatusResponse_Holder" - self.pyclass = Holder - - class ComplianceManagerClearComplianceStatus_Dec(ElementDeclaration): - literal = "ComplianceManagerClearComplianceStatus" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ComplianceManagerClearComplianceStatus") - kw["aname"] = "_ComplianceManagerClearComplianceStatus" - if ns0.ComplianceManagerClearComplianceStatusRequestType_Def not in ns0.ComplianceManagerClearComplianceStatus_Dec.__bases__: - bases = list(ns0.ComplianceManagerClearComplianceStatus_Dec.__bases__) - bases.insert(0, ns0.ComplianceManagerClearComplianceStatusRequestType_Def) - ns0.ComplianceManagerClearComplianceStatus_Dec.__bases__ = tuple(bases) - - ns0.ComplianceManagerClearComplianceStatusRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerClearComplianceStatus_Dec_Holder" - - class ComplianceManagerClearComplianceStatusResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ComplianceManagerClearComplianceStatusResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ComplianceManagerClearComplianceStatusResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ComplianceManagerClearComplianceStatusResponse") - kw["aname"] = "_ComplianceManagerClearComplianceStatusResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ComplianceManagerClearComplianceStatusResponse_Holder" - self.pyclass = Holder - - class ComplianceManagerQueryExpressionMetadata_Dec(ElementDeclaration): - literal = "ComplianceManagerQueryExpressionMetadata" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ComplianceManagerQueryExpressionMetadata") - kw["aname"] = "_ComplianceManagerQueryExpressionMetadata" - if ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def not in ns0.ComplianceManagerQueryExpressionMetadata_Dec.__bases__: - bases = list(ns0.ComplianceManagerQueryExpressionMetadata_Dec.__bases__) - bases.insert(0, ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def) - ns0.ComplianceManagerQueryExpressionMetadata_Dec.__bases__ = tuple(bases) - - ns0.ComplianceManagerQueryExpressionMetadataRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ComplianceManagerQueryExpressionMetadata_Dec_Holder" - - class ComplianceManagerQueryExpressionMetadataResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ComplianceManagerQueryExpressionMetadataResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ComplianceManagerQueryExpressionMetadataResponse_Dec.schema - TClist = [GTD("urn:vim25","ProfileExpressionMetadata",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ComplianceManagerQueryExpressionMetadataResponse") - kw["aname"] = "_ComplianceManagerQueryExpressionMetadataResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ComplianceManagerQueryExpressionMetadataResponse_Holder" - self.pyclass = Holder - - class ProfileDestroy_Dec(ElementDeclaration): - literal = "ProfileDestroy" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileDestroy") - kw["aname"] = "_ProfileDestroy" - if ns0.ProfileDestroyRequestType_Def not in ns0.ProfileDestroy_Dec.__bases__: - bases = list(ns0.ProfileDestroy_Dec.__bases__) - bases.insert(0, ns0.ProfileDestroyRequestType_Def) - ns0.ProfileDestroy_Dec.__bases__ = tuple(bases) - - ns0.ProfileDestroyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileDestroy_Dec_Holder" - - class ProfileDestroyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileDestroyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileDestroyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ProfileDestroyResponse") - kw["aname"] = "_ProfileDestroyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ProfileDestroyResponse_Holder" - self.pyclass = Holder - - class ProfileAssociate_Dec(ElementDeclaration): - literal = "ProfileAssociate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileAssociate") - kw["aname"] = "_ProfileAssociate" - if ns0.ProfileAssociateRequestType_Def not in ns0.ProfileAssociate_Dec.__bases__: - bases = list(ns0.ProfileAssociate_Dec.__bases__) - bases.insert(0, ns0.ProfileAssociateRequestType_Def) - ns0.ProfileAssociate_Dec.__bases__ = tuple(bases) - - ns0.ProfileAssociateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileAssociate_Dec_Holder" - - class ProfileAssociateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileAssociateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileAssociateResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ProfileAssociateResponse") - kw["aname"] = "_ProfileAssociateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ProfileAssociateResponse_Holder" - self.pyclass = Holder - - class ProfileDissociate_Dec(ElementDeclaration): - literal = "ProfileDissociate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileDissociate") - kw["aname"] = "_ProfileDissociate" - if ns0.ProfileDissociateRequestType_Def not in ns0.ProfileDissociate_Dec.__bases__: - bases = list(ns0.ProfileDissociate_Dec.__bases__) - bases.insert(0, ns0.ProfileDissociateRequestType_Def) - ns0.ProfileDissociate_Dec.__bases__ = tuple(bases) - - ns0.ProfileDissociateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileDissociate_Dec_Holder" - - class ProfileDissociateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileDissociateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileDissociateResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ProfileDissociateResponse") - kw["aname"] = "_ProfileDissociateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ProfileDissociateResponse_Holder" - self.pyclass = Holder - - class ProfileCheckCompliance_Dec(ElementDeclaration): - literal = "ProfileCheckCompliance" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileCheckCompliance") - kw["aname"] = "_ProfileCheckCompliance" - if ns0.ProfileCheckComplianceRequestType_Def not in ns0.ProfileCheckCompliance_Dec.__bases__: - bases = list(ns0.ProfileCheckCompliance_Dec.__bases__) - bases.insert(0, ns0.ProfileCheckComplianceRequestType_Def) - ns0.ProfileCheckCompliance_Dec.__bases__ = tuple(bases) - - ns0.ProfileCheckComplianceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileCheckCompliance_Dec_Holder" - - class ProfileCheckComplianceResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileCheckComplianceResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileCheckComplianceResponse_Dec.schema - TClist = [GTD("urn:vim25","ComplianceResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ProfileCheckComplianceResponse") - kw["aname"] = "_ProfileCheckComplianceResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ProfileCheckComplianceResponse_Holder" - self.pyclass = Holder - - class ProfileCheckCompliance_Task_Dec(ElementDeclaration): - literal = "ProfileCheckCompliance_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileCheckCompliance_Task") - kw["aname"] = "_ProfileCheckCompliance_Task" - if ns0.ProfileCheckComplianceRequestType_Def not in ns0.ProfileCheckCompliance_Task_Dec.__bases__: - bases = list(ns0.ProfileCheckCompliance_Task_Dec.__bases__) - bases.insert(0, ns0.ProfileCheckComplianceRequestType_Def) - ns0.ProfileCheckCompliance_Task_Dec.__bases__ = tuple(bases) - - ns0.ProfileCheckComplianceRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileCheckCompliance_Task_Dec_Holder" - - class ProfileCheckCompliance_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileCheckCompliance_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileCheckCompliance_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ProfileCheckCompliance_TaskResponse") - kw["aname"] = "_ProfileCheckCompliance_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ProfileCheckCompliance_TaskResponse_Holder" - self.pyclass = Holder - - class ProfileExportProfile_Dec(ElementDeclaration): - literal = "ProfileExportProfile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileExportProfile") - kw["aname"] = "_ProfileExportProfile" - if ns0.ProfileExportProfileRequestType_Def not in ns0.ProfileExportProfile_Dec.__bases__: - bases = list(ns0.ProfileExportProfile_Dec.__bases__) - bases.insert(0, ns0.ProfileExportProfileRequestType_Def) - ns0.ProfileExportProfile_Dec.__bases__ = tuple(bases) - - ns0.ProfileExportProfileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileExportProfile_Dec_Holder" - - class ProfileExportProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileExportProfileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileExportProfileResponse_Dec.schema - TClist = [ZSI.TC.String(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ProfileExportProfileResponse") - kw["aname"] = "_ProfileExportProfileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "ProfileExportProfileResponse_Holder" - self.pyclass = Holder - - class CreateProfile_Dec(ElementDeclaration): - literal = "CreateProfile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateProfile") - kw["aname"] = "_CreateProfile" - if ns0.CreateProfileRequestType_Def not in ns0.CreateProfile_Dec.__bases__: - bases = list(ns0.CreateProfile_Dec.__bases__) - bases.insert(0, ns0.CreateProfileRequestType_Def) - ns0.CreateProfile_Dec.__bases__ = tuple(bases) - - ns0.CreateProfileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateProfile_Dec_Holder" - - class CreateProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateProfileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateProfileResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateProfileResponse") - kw["aname"] = "_CreateProfileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateProfileResponse_Holder" - self.pyclass = Holder - - class ProfileQueryPolicyMetadata_Dec(ElementDeclaration): - literal = "ProfileQueryPolicyMetadata" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileQueryPolicyMetadata") - kw["aname"] = "_ProfileQueryPolicyMetadata" - if ns0.ProfileQueryPolicyMetadataRequestType_Def not in ns0.ProfileQueryPolicyMetadata_Dec.__bases__: - bases = list(ns0.ProfileQueryPolicyMetadata_Dec.__bases__) - bases.insert(0, ns0.ProfileQueryPolicyMetadataRequestType_Def) - ns0.ProfileQueryPolicyMetadata_Dec.__bases__ = tuple(bases) - - ns0.ProfileQueryPolicyMetadataRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileQueryPolicyMetadata_Dec_Holder" - - class ProfileQueryPolicyMetadataResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileQueryPolicyMetadataResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileQueryPolicyMetadataResponse_Dec.schema - TClist = [GTD("urn:vim25","ProfilePolicyMetadata",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ProfileQueryPolicyMetadataResponse") - kw["aname"] = "_ProfileQueryPolicyMetadataResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ProfileQueryPolicyMetadataResponse_Holder" - self.pyclass = Holder - - class ProfileFindAssociatedProfile_Dec(ElementDeclaration): - literal = "ProfileFindAssociatedProfile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ProfileFindAssociatedProfile") - kw["aname"] = "_ProfileFindAssociatedProfile" - if ns0.ProfileFindAssociatedProfileRequestType_Def not in ns0.ProfileFindAssociatedProfile_Dec.__bases__: - bases = list(ns0.ProfileFindAssociatedProfile_Dec.__bases__) - bases.insert(0, ns0.ProfileFindAssociatedProfileRequestType_Def) - ns0.ProfileFindAssociatedProfile_Dec.__bases__ = tuple(bases) - - ns0.ProfileFindAssociatedProfileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ProfileFindAssociatedProfile_Dec_Holder" - - class ProfileFindAssociatedProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ProfileFindAssociatedProfileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ProfileFindAssociatedProfileResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ProfileFindAssociatedProfileResponse") - kw["aname"] = "_ProfileFindAssociatedProfileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ProfileFindAssociatedProfileResponse_Holder" - self.pyclass = Holder - - class ClusterProfileUpdate_Dec(ElementDeclaration): - literal = "ClusterProfileUpdate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ClusterProfileUpdate") - kw["aname"] = "_ClusterProfileUpdate" - if ns0.ClusterProfileUpdateRequestType_Def not in ns0.ClusterProfileUpdate_Dec.__bases__: - bases = list(ns0.ClusterProfileUpdate_Dec.__bases__) - bases.insert(0, ns0.ClusterProfileUpdateRequestType_Def) - ns0.ClusterProfileUpdate_Dec.__bases__ = tuple(bases) - - ns0.ClusterProfileUpdateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ClusterProfileUpdate_Dec_Holder" - - class ClusterProfileUpdateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ClusterProfileUpdateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ClusterProfileUpdateResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ClusterProfileUpdateResponse") - kw["aname"] = "_ClusterProfileUpdateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ClusterProfileUpdateResponse_Holder" - self.pyclass = Holder - - class HostProfileUpdateReferenceHost_Dec(ElementDeclaration): - literal = "HostProfileUpdateReferenceHost" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileUpdateReferenceHost") - kw["aname"] = "_HostProfileUpdateReferenceHost" - if ns0.HostProfileUpdateReferenceHostRequestType_Def not in ns0.HostProfileUpdateReferenceHost_Dec.__bases__: - bases = list(ns0.HostProfileUpdateReferenceHost_Dec.__bases__) - bases.insert(0, ns0.HostProfileUpdateReferenceHostRequestType_Def) - ns0.HostProfileUpdateReferenceHost_Dec.__bases__ = tuple(bases) - - ns0.HostProfileUpdateReferenceHostRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileUpdateReferenceHost_Dec_Holder" - - class HostProfileUpdateReferenceHostResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileUpdateReferenceHostResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileUpdateReferenceHostResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","HostProfileUpdateReferenceHostResponse") - kw["aname"] = "_HostProfileUpdateReferenceHostResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "HostProfileUpdateReferenceHostResponse_Holder" - self.pyclass = Holder - - class HostProfileUpdate_Dec(ElementDeclaration): - literal = "HostProfileUpdate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileUpdate") - kw["aname"] = "_HostProfileUpdate" - if ns0.HostProfileUpdateRequestType_Def not in ns0.HostProfileUpdate_Dec.__bases__: - bases = list(ns0.HostProfileUpdate_Dec.__bases__) - bases.insert(0, ns0.HostProfileUpdateRequestType_Def) - ns0.HostProfileUpdate_Dec.__bases__ = tuple(bases) - - ns0.HostProfileUpdateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileUpdate_Dec_Holder" - - class HostProfileUpdateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileUpdateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileUpdateResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","HostProfileUpdateResponse") - kw["aname"] = "_HostProfileUpdateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "HostProfileUpdateResponse_Holder" - self.pyclass = Holder - - class HostProfileExecute_Dec(ElementDeclaration): - literal = "HostProfileExecute" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileExecute") - kw["aname"] = "_HostProfileExecute" - if ns0.HostProfileExecuteRequestType_Def not in ns0.HostProfileExecute_Dec.__bases__: - bases = list(ns0.HostProfileExecute_Dec.__bases__) - bases.insert(0, ns0.HostProfileExecuteRequestType_Def) - ns0.HostProfileExecute_Dec.__bases__ = tuple(bases) - - ns0.HostProfileExecuteRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileExecute_Dec_Holder" - - class HostProfileExecuteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileExecuteResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileExecuteResponse_Dec.schema - TClist = [GTD("urn:vim25","ProfileExecuteResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","HostProfileExecuteResponse") - kw["aname"] = "_HostProfileExecuteResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "HostProfileExecuteResponse_Holder" - self.pyclass = Holder - - class HostProfileApply_Dec(ElementDeclaration): - literal = "HostProfileApply" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileApply") - kw["aname"] = "_HostProfileApply" - if ns0.HostProfileApplyRequestType_Def not in ns0.HostProfileApply_Dec.__bases__: - bases = list(ns0.HostProfileApply_Dec.__bases__) - bases.insert(0, ns0.HostProfileApplyRequestType_Def) - ns0.HostProfileApply_Dec.__bases__ = tuple(bases) - - ns0.HostProfileApplyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileApply_Dec_Holder" - - class HostProfileApplyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileApplyResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileApplyResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","HostProfileApplyResponse") - kw["aname"] = "_HostProfileApplyResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "HostProfileApplyResponse_Holder" - self.pyclass = Holder - - class HostProfileApply_Task_Dec(ElementDeclaration): - literal = "HostProfileApply_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileApply_Task") - kw["aname"] = "_HostProfileApply_Task" - if ns0.HostProfileApplyRequestType_Def not in ns0.HostProfileApply_Task_Dec.__bases__: - bases = list(ns0.HostProfileApply_Task_Dec.__bases__) - bases.insert(0, ns0.HostProfileApplyRequestType_Def) - ns0.HostProfileApply_Task_Dec.__bases__ = tuple(bases) - - ns0.HostProfileApplyRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileApply_Task_Dec_Holder" - - class HostProfileApply_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileApply_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileApply_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","HostProfileApply_TaskResponse") - kw["aname"] = "_HostProfileApply_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "HostProfileApply_TaskResponse_Holder" - self.pyclass = Holder - - class HostProfileGenerateConfigTaskList_Dec(ElementDeclaration): - literal = "HostProfileGenerateConfigTaskList" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileGenerateConfigTaskList") - kw["aname"] = "_HostProfileGenerateConfigTaskList" - if ns0.HostProfileGenerateConfigTaskListRequestType_Def not in ns0.HostProfileGenerateConfigTaskList_Dec.__bases__: - bases = list(ns0.HostProfileGenerateConfigTaskList_Dec.__bases__) - bases.insert(0, ns0.HostProfileGenerateConfigTaskListRequestType_Def) - ns0.HostProfileGenerateConfigTaskList_Dec.__bases__ = tuple(bases) - - ns0.HostProfileGenerateConfigTaskListRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileGenerateConfigTaskList_Dec_Holder" - - class HostProfileGenerateConfigTaskListResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileGenerateConfigTaskListResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileGenerateConfigTaskListResponse_Dec.schema - TClist = [GTD("urn:vim25","HostProfileManagerConfigTaskList",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","HostProfileGenerateConfigTaskListResponse") - kw["aname"] = "_HostProfileGenerateConfigTaskListResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "HostProfileGenerateConfigTaskListResponse_Holder" - self.pyclass = Holder - - class HostProfileQueryProfileMetadata_Dec(ElementDeclaration): - literal = "HostProfileQueryProfileMetadata" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileQueryProfileMetadata") - kw["aname"] = "_HostProfileQueryProfileMetadata" - if ns0.HostProfileQueryProfileMetadataRequestType_Def not in ns0.HostProfileQueryProfileMetadata_Dec.__bases__: - bases = list(ns0.HostProfileQueryProfileMetadata_Dec.__bases__) - bases.insert(0, ns0.HostProfileQueryProfileMetadataRequestType_Def) - ns0.HostProfileQueryProfileMetadata_Dec.__bases__ = tuple(bases) - - ns0.HostProfileQueryProfileMetadataRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileQueryProfileMetadata_Dec_Holder" - - class HostProfileQueryProfileMetadataResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileQueryProfileMetadataResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileQueryProfileMetadataResponse_Dec.schema - TClist = [GTD("urn:vim25","ProfileMetadata",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","HostProfileQueryProfileMetadataResponse") - kw["aname"] = "_HostProfileQueryProfileMetadataResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "HostProfileQueryProfileMetadataResponse_Holder" - self.pyclass = Holder - - class HostProfileCreateDefaultProfile_Dec(ElementDeclaration): - literal = "HostProfileCreateDefaultProfile" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","HostProfileCreateDefaultProfile") - kw["aname"] = "_HostProfileCreateDefaultProfile" - if ns0.HostProfileCreateDefaultProfileRequestType_Def not in ns0.HostProfileCreateDefaultProfile_Dec.__bases__: - bases = list(ns0.HostProfileCreateDefaultProfile_Dec.__bases__) - bases.insert(0, ns0.HostProfileCreateDefaultProfileRequestType_Def) - ns0.HostProfileCreateDefaultProfile_Dec.__bases__ = tuple(bases) - - ns0.HostProfileCreateDefaultProfileRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "HostProfileCreateDefaultProfile_Dec_Holder" - - class HostProfileCreateDefaultProfileResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "HostProfileCreateDefaultProfileResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.HostProfileCreateDefaultProfileResponse_Dec.schema - TClist = [GTD("urn:vim25","ApplyProfile",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","HostProfileCreateDefaultProfileResponse") - kw["aname"] = "_HostProfileCreateDefaultProfileResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "HostProfileCreateDefaultProfileResponse_Holder" - self.pyclass = Holder - - class RemoveScheduledTask_Dec(ElementDeclaration): - literal = "RemoveScheduledTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveScheduledTask") - kw["aname"] = "_RemoveScheduledTask" - if ns0.RemoveScheduledTaskRequestType_Def not in ns0.RemoveScheduledTask_Dec.__bases__: - bases = list(ns0.RemoveScheduledTask_Dec.__bases__) - bases.insert(0, ns0.RemoveScheduledTaskRequestType_Def) - ns0.RemoveScheduledTask_Dec.__bases__ = tuple(bases) - - ns0.RemoveScheduledTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveScheduledTask_Dec_Holder" - - class RemoveScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveScheduledTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveScheduledTaskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveScheduledTaskResponse") - kw["aname"] = "_RemoveScheduledTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveScheduledTaskResponse_Holder" - self.pyclass = Holder - - class ReconfigureScheduledTask_Dec(ElementDeclaration): - literal = "ReconfigureScheduledTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ReconfigureScheduledTask") - kw["aname"] = "_ReconfigureScheduledTask" - if ns0.ReconfigureScheduledTaskRequestType_Def not in ns0.ReconfigureScheduledTask_Dec.__bases__: - bases = list(ns0.ReconfigureScheduledTask_Dec.__bases__) - bases.insert(0, ns0.ReconfigureScheduledTaskRequestType_Def) - ns0.ReconfigureScheduledTask_Dec.__bases__ = tuple(bases) - - ns0.ReconfigureScheduledTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ReconfigureScheduledTask_Dec_Holder" - - class ReconfigureScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ReconfigureScheduledTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ReconfigureScheduledTaskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ReconfigureScheduledTaskResponse") - kw["aname"] = "_ReconfigureScheduledTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ReconfigureScheduledTaskResponse_Holder" - self.pyclass = Holder - - class RunScheduledTask_Dec(ElementDeclaration): - literal = "RunScheduledTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RunScheduledTask") - kw["aname"] = "_RunScheduledTask" - if ns0.RunScheduledTaskRequestType_Def not in ns0.RunScheduledTask_Dec.__bases__: - bases = list(ns0.RunScheduledTask_Dec.__bases__) - bases.insert(0, ns0.RunScheduledTaskRequestType_Def) - ns0.RunScheduledTask_Dec.__bases__ = tuple(bases) - - ns0.RunScheduledTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RunScheduledTask_Dec_Holder" - - class RunScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RunScheduledTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RunScheduledTaskResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RunScheduledTaskResponse") - kw["aname"] = "_RunScheduledTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RunScheduledTaskResponse_Holder" - self.pyclass = Holder - - class CreateScheduledTask_Dec(ElementDeclaration): - literal = "CreateScheduledTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateScheduledTask") - kw["aname"] = "_CreateScheduledTask" - if ns0.CreateScheduledTaskRequestType_Def not in ns0.CreateScheduledTask_Dec.__bases__: - bases = list(ns0.CreateScheduledTask_Dec.__bases__) - bases.insert(0, ns0.CreateScheduledTaskRequestType_Def) - ns0.CreateScheduledTask_Dec.__bases__ = tuple(bases) - - ns0.CreateScheduledTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateScheduledTask_Dec_Holder" - - class CreateScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateScheduledTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateScheduledTaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateScheduledTaskResponse") - kw["aname"] = "_CreateScheduledTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateScheduledTaskResponse_Holder" - self.pyclass = Holder - - class RetrieveEntityScheduledTask_Dec(ElementDeclaration): - literal = "RetrieveEntityScheduledTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveEntityScheduledTask") - kw["aname"] = "_RetrieveEntityScheduledTask" - if ns0.RetrieveEntityScheduledTaskRequestType_Def not in ns0.RetrieveEntityScheduledTask_Dec.__bases__: - bases = list(ns0.RetrieveEntityScheduledTask_Dec.__bases__) - bases.insert(0, ns0.RetrieveEntityScheduledTaskRequestType_Def) - ns0.RetrieveEntityScheduledTask_Dec.__bases__ = tuple(bases) - - ns0.RetrieveEntityScheduledTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveEntityScheduledTask_Dec_Holder" - - class RetrieveEntityScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveEntityScheduledTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveEntityScheduledTaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveEntityScheduledTaskResponse") - kw["aname"] = "_RetrieveEntityScheduledTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveEntityScheduledTaskResponse_Holder" - self.pyclass = Holder - - class CreateObjectScheduledTask_Dec(ElementDeclaration): - literal = "CreateObjectScheduledTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateObjectScheduledTask") - kw["aname"] = "_CreateObjectScheduledTask" - if ns0.CreateObjectScheduledTaskRequestType_Def not in ns0.CreateObjectScheduledTask_Dec.__bases__: - bases = list(ns0.CreateObjectScheduledTask_Dec.__bases__) - bases.insert(0, ns0.CreateObjectScheduledTaskRequestType_Def) - ns0.CreateObjectScheduledTask_Dec.__bases__ = tuple(bases) - - ns0.CreateObjectScheduledTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateObjectScheduledTask_Dec_Holder" - - class CreateObjectScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateObjectScheduledTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateObjectScheduledTaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateObjectScheduledTaskResponse") - kw["aname"] = "_CreateObjectScheduledTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateObjectScheduledTaskResponse_Holder" - self.pyclass = Holder - - class RetrieveObjectScheduledTask_Dec(ElementDeclaration): - literal = "RetrieveObjectScheduledTask" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RetrieveObjectScheduledTask") - kw["aname"] = "_RetrieveObjectScheduledTask" - if ns0.RetrieveObjectScheduledTaskRequestType_Def not in ns0.RetrieveObjectScheduledTask_Dec.__bases__: - bases = list(ns0.RetrieveObjectScheduledTask_Dec.__bases__) - bases.insert(0, ns0.RetrieveObjectScheduledTaskRequestType_Def) - ns0.RetrieveObjectScheduledTask_Dec.__bases__ = tuple(bases) - - ns0.RetrieveObjectScheduledTaskRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RetrieveObjectScheduledTask_Dec_Holder" - - class RetrieveObjectScheduledTaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RetrieveObjectScheduledTaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RetrieveObjectScheduledTaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RetrieveObjectScheduledTaskResponse") - kw["aname"] = "_RetrieveObjectScheduledTaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "RetrieveObjectScheduledTaskResponse_Holder" - self.pyclass = Holder - - class OpenInventoryViewFolder_Dec(ElementDeclaration): - literal = "OpenInventoryViewFolder" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","OpenInventoryViewFolder") - kw["aname"] = "_OpenInventoryViewFolder" - if ns0.OpenInventoryViewFolderRequestType_Def not in ns0.OpenInventoryViewFolder_Dec.__bases__: - bases = list(ns0.OpenInventoryViewFolder_Dec.__bases__) - bases.insert(0, ns0.OpenInventoryViewFolderRequestType_Def) - ns0.OpenInventoryViewFolder_Dec.__bases__ = tuple(bases) - - ns0.OpenInventoryViewFolderRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "OpenInventoryViewFolder_Dec_Holder" - - class OpenInventoryViewFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "OpenInventoryViewFolderResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.OpenInventoryViewFolderResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","OpenInventoryViewFolderResponse") - kw["aname"] = "_OpenInventoryViewFolderResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "OpenInventoryViewFolderResponse_Holder" - self.pyclass = Holder - - class CloseInventoryViewFolder_Dec(ElementDeclaration): - literal = "CloseInventoryViewFolder" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CloseInventoryViewFolder") - kw["aname"] = "_CloseInventoryViewFolder" - if ns0.CloseInventoryViewFolderRequestType_Def not in ns0.CloseInventoryViewFolder_Dec.__bases__: - bases = list(ns0.CloseInventoryViewFolder_Dec.__bases__) - bases.insert(0, ns0.CloseInventoryViewFolderRequestType_Def) - ns0.CloseInventoryViewFolder_Dec.__bases__ = tuple(bases) - - ns0.CloseInventoryViewFolderRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CloseInventoryViewFolder_Dec_Holder" - - class CloseInventoryViewFolderResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CloseInventoryViewFolderResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CloseInventoryViewFolderResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CloseInventoryViewFolderResponse") - kw["aname"] = "_CloseInventoryViewFolderResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "CloseInventoryViewFolderResponse_Holder" - self.pyclass = Holder - - class ModifyListView_Dec(ElementDeclaration): - literal = "ModifyListView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ModifyListView") - kw["aname"] = "_ModifyListView" - if ns0.ModifyListViewRequestType_Def not in ns0.ModifyListView_Dec.__bases__: - bases = list(ns0.ModifyListView_Dec.__bases__) - bases.insert(0, ns0.ModifyListViewRequestType_Def) - ns0.ModifyListView_Dec.__bases__ = tuple(bases) - - ns0.ModifyListViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ModifyListView_Dec_Holder" - - class ModifyListViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ModifyListViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ModifyListViewResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ModifyListViewResponse") - kw["aname"] = "_ModifyListViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ModifyListViewResponse_Holder" - self.pyclass = Holder - - class ResetListView_Dec(ElementDeclaration): - literal = "ResetListView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetListView") - kw["aname"] = "_ResetListView" - if ns0.ResetListViewRequestType_Def not in ns0.ResetListView_Dec.__bases__: - bases = list(ns0.ResetListView_Dec.__bases__) - bases.insert(0, ns0.ResetListViewRequestType_Def) - ns0.ResetListView_Dec.__bases__ = tuple(bases) - - ns0.ResetListViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetListView_Dec_Holder" - - class ResetListViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetListViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetListViewResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","ResetListViewResponse") - kw["aname"] = "_ResetListViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "ResetListViewResponse_Holder" - self.pyclass = Holder - - class ResetListViewFromView_Dec(ElementDeclaration): - literal = "ResetListViewFromView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","ResetListViewFromView") - kw["aname"] = "_ResetListViewFromView" - if ns0.ResetListViewFromViewRequestType_Def not in ns0.ResetListViewFromView_Dec.__bases__: - bases = list(ns0.ResetListViewFromView_Dec.__bases__) - bases.insert(0, ns0.ResetListViewFromViewRequestType_Def) - ns0.ResetListViewFromView_Dec.__bases__ = tuple(bases) - - ns0.ResetListViewFromViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "ResetListViewFromView_Dec_Holder" - - class ResetListViewFromViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "ResetListViewFromViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.ResetListViewFromViewResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","ResetListViewFromViewResponse") - kw["aname"] = "_ResetListViewFromViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "ResetListViewFromViewResponse_Holder" - self.pyclass = Holder - - class DestroyView_Dec(ElementDeclaration): - literal = "DestroyView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","DestroyView") - kw["aname"] = "_DestroyView" - if ns0.DestroyViewRequestType_Def not in ns0.DestroyView_Dec.__bases__: - bases = list(ns0.DestroyView_Dec.__bases__) - bases.insert(0, ns0.DestroyViewRequestType_Def) - ns0.DestroyView_Dec.__bases__ = tuple(bases) - - ns0.DestroyViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "DestroyView_Dec_Holder" - - class DestroyViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "DestroyViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.DestroyViewResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","DestroyViewResponse") - kw["aname"] = "_DestroyViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "DestroyViewResponse_Holder" - self.pyclass = Holder - - class CreateInventoryView_Dec(ElementDeclaration): - literal = "CreateInventoryView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateInventoryView") - kw["aname"] = "_CreateInventoryView" - if ns0.CreateInventoryViewRequestType_Def not in ns0.CreateInventoryView_Dec.__bases__: - bases = list(ns0.CreateInventoryView_Dec.__bases__) - bases.insert(0, ns0.CreateInventoryViewRequestType_Def) - ns0.CreateInventoryView_Dec.__bases__ = tuple(bases) - - ns0.CreateInventoryViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateInventoryView_Dec_Holder" - - class CreateInventoryViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateInventoryViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateInventoryViewResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateInventoryViewResponse") - kw["aname"] = "_CreateInventoryViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateInventoryViewResponse_Holder" - self.pyclass = Holder - - class CreateContainerView_Dec(ElementDeclaration): - literal = "CreateContainerView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateContainerView") - kw["aname"] = "_CreateContainerView" - if ns0.CreateContainerViewRequestType_Def not in ns0.CreateContainerView_Dec.__bases__: - bases = list(ns0.CreateContainerView_Dec.__bases__) - bases.insert(0, ns0.CreateContainerViewRequestType_Def) - ns0.CreateContainerView_Dec.__bases__ = tuple(bases) - - ns0.CreateContainerViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateContainerView_Dec_Holder" - - class CreateContainerViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateContainerViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateContainerViewResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateContainerViewResponse") - kw["aname"] = "_CreateContainerViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateContainerViewResponse_Holder" - self.pyclass = Holder - - class CreateListView_Dec(ElementDeclaration): - literal = "CreateListView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateListView") - kw["aname"] = "_CreateListView" - if ns0.CreateListViewRequestType_Def not in ns0.CreateListView_Dec.__bases__: - bases = list(ns0.CreateListView_Dec.__bases__) - bases.insert(0, ns0.CreateListViewRequestType_Def) - ns0.CreateListView_Dec.__bases__ = tuple(bases) - - ns0.CreateListViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateListView_Dec_Holder" - - class CreateListViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateListViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateListViewResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateListViewResponse") - kw["aname"] = "_CreateListViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateListViewResponse_Holder" - self.pyclass = Holder - - class CreateListViewFromView_Dec(ElementDeclaration): - literal = "CreateListViewFromView" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CreateListViewFromView") - kw["aname"] = "_CreateListViewFromView" - if ns0.CreateListViewFromViewRequestType_Def not in ns0.CreateListViewFromView_Dec.__bases__: - bases = list(ns0.CreateListViewFromView_Dec.__bases__) - bases.insert(0, ns0.CreateListViewFromViewRequestType_Def) - ns0.CreateListViewFromView_Dec.__bases__ = tuple(bases) - - ns0.CreateListViewFromViewRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CreateListViewFromView_Dec_Holder" - - class CreateListViewFromViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CreateListViewFromViewResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CreateListViewFromViewResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CreateListViewFromViewResponse") - kw["aname"] = "_CreateListViewFromViewResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CreateListViewFromViewResponse_Holder" - self.pyclass = Holder - - class RevertToSnapshot_Dec(ElementDeclaration): - literal = "RevertToSnapshot" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RevertToSnapshot") - kw["aname"] = "_RevertToSnapshot" - if ns0.RevertToSnapshotRequestType_Def not in ns0.RevertToSnapshot_Dec.__bases__: - bases = list(ns0.RevertToSnapshot_Dec.__bases__) - bases.insert(0, ns0.RevertToSnapshotRequestType_Def) - ns0.RevertToSnapshot_Dec.__bases__ = tuple(bases) - - ns0.RevertToSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RevertToSnapshot_Dec_Holder" - - class RevertToSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RevertToSnapshotResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RevertToSnapshotResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RevertToSnapshotResponse") - kw["aname"] = "_RevertToSnapshotResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RevertToSnapshotResponse_Holder" - self.pyclass = Holder - - class RevertToSnapshot_Task_Dec(ElementDeclaration): - literal = "RevertToSnapshot_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RevertToSnapshot_Task") - kw["aname"] = "_RevertToSnapshot_Task" - if ns0.RevertToSnapshotRequestType_Def not in ns0.RevertToSnapshot_Task_Dec.__bases__: - bases = list(ns0.RevertToSnapshot_Task_Dec.__bases__) - bases.insert(0, ns0.RevertToSnapshotRequestType_Def) - ns0.RevertToSnapshot_Task_Dec.__bases__ = tuple(bases) - - ns0.RevertToSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RevertToSnapshot_Task_Dec_Holder" - - class RevertToSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RevertToSnapshot_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RevertToSnapshot_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RevertToSnapshot_TaskResponse") - kw["aname"] = "_RevertToSnapshot_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RevertToSnapshot_TaskResponse_Holder" - self.pyclass = Holder - - class RemoveSnapshot_Dec(ElementDeclaration): - literal = "RemoveSnapshot" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveSnapshot") - kw["aname"] = "_RemoveSnapshot" - if ns0.RemoveSnapshotRequestType_Def not in ns0.RemoveSnapshot_Dec.__bases__: - bases = list(ns0.RemoveSnapshot_Dec.__bases__) - bases.insert(0, ns0.RemoveSnapshotRequestType_Def) - ns0.RemoveSnapshot_Dec.__bases__ = tuple(bases) - - ns0.RemoveSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveSnapshot_Dec_Holder" - - class RemoveSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveSnapshotResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveSnapshotResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RemoveSnapshotResponse") - kw["aname"] = "_RemoveSnapshotResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RemoveSnapshotResponse_Holder" - self.pyclass = Holder - - class RemoveSnapshot_Task_Dec(ElementDeclaration): - literal = "RemoveSnapshot_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RemoveSnapshot_Task") - kw["aname"] = "_RemoveSnapshot_Task" - if ns0.RemoveSnapshotRequestType_Def not in ns0.RemoveSnapshot_Task_Dec.__bases__: - bases = list(ns0.RemoveSnapshot_Task_Dec.__bases__) - bases.insert(0, ns0.RemoveSnapshotRequestType_Def) - ns0.RemoveSnapshot_Task_Dec.__bases__ = tuple(bases) - - ns0.RemoveSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RemoveSnapshot_Task_Dec_Holder" - - class RemoveSnapshot_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RemoveSnapshot_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RemoveSnapshot_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","RemoveSnapshot_TaskResponse") - kw["aname"] = "_RemoveSnapshot_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "RemoveSnapshot_TaskResponse_Holder" - self.pyclass = Holder - - class RenameSnapshot_Dec(ElementDeclaration): - literal = "RenameSnapshot" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","RenameSnapshot") - kw["aname"] = "_RenameSnapshot" - if ns0.RenameSnapshotRequestType_Def not in ns0.RenameSnapshot_Dec.__bases__: - bases = list(ns0.RenameSnapshot_Dec.__bases__) - bases.insert(0, ns0.RenameSnapshotRequestType_Def) - ns0.RenameSnapshot_Dec.__bases__ = tuple(bases) - - ns0.RenameSnapshotRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "RenameSnapshot_Dec_Holder" - - class RenameSnapshotResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "RenameSnapshotResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.RenameSnapshotResponse_Dec.schema - TClist = [] - kw["pname"] = ("urn:vim25","RenameSnapshotResponse") - kw["aname"] = "_RenameSnapshotResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - return - Holder.__name__ = "RenameSnapshotResponse_Holder" - self.pyclass = Holder - - class CheckCompatibility_Dec(ElementDeclaration): - literal = "CheckCompatibility" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckCompatibility") - kw["aname"] = "_CheckCompatibility" - if ns0.CheckCompatibilityRequestType_Def not in ns0.CheckCompatibility_Dec.__bases__: - bases = list(ns0.CheckCompatibility_Dec.__bases__) - bases.insert(0, ns0.CheckCompatibilityRequestType_Def) - ns0.CheckCompatibility_Dec.__bases__ = tuple(bases) - - ns0.CheckCompatibilityRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckCompatibility_Dec_Holder" - - class CheckCompatibilityResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckCompatibilityResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckCompatibilityResponse_Dec.schema - TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckCompatibilityResponse") - kw["aname"] = "_CheckCompatibilityResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "CheckCompatibilityResponse_Holder" - self.pyclass = Holder - - class CheckCompatibility_Task_Dec(ElementDeclaration): - literal = "CheckCompatibility_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckCompatibility_Task") - kw["aname"] = "_CheckCompatibility_Task" - if ns0.CheckCompatibilityRequestType_Def not in ns0.CheckCompatibility_Task_Dec.__bases__: - bases = list(ns0.CheckCompatibility_Task_Dec.__bases__) - bases.insert(0, ns0.CheckCompatibilityRequestType_Def) - ns0.CheckCompatibility_Task_Dec.__bases__ = tuple(bases) - - ns0.CheckCompatibilityRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckCompatibility_Task_Dec_Holder" - - class CheckCompatibility_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckCompatibility_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckCompatibility_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckCompatibility_TaskResponse") - kw["aname"] = "_CheckCompatibility_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CheckCompatibility_TaskResponse_Holder" - self.pyclass = Holder - - class QueryVMotionCompatibilityEx_Dec(ElementDeclaration): - literal = "QueryVMotionCompatibilityEx" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityEx") - kw["aname"] = "_QueryVMotionCompatibilityEx" - if ns0.QueryVMotionCompatibilityExRequestType_Def not in ns0.QueryVMotionCompatibilityEx_Dec.__bases__: - bases = list(ns0.QueryVMotionCompatibilityEx_Dec.__bases__) - bases.insert(0, ns0.QueryVMotionCompatibilityExRequestType_Def) - ns0.QueryVMotionCompatibilityEx_Dec.__bases__ = tuple(bases) - - ns0.QueryVMotionCompatibilityExRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVMotionCompatibilityEx_Dec_Holder" - - class QueryVMotionCompatibilityExResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVMotionCompatibilityExResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVMotionCompatibilityExResponse_Dec.schema - TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityExResponse") - kw["aname"] = "_QueryVMotionCompatibilityExResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "QueryVMotionCompatibilityExResponse_Holder" - self.pyclass = Holder - - class QueryVMotionCompatibilityEx_Task_Dec(ElementDeclaration): - literal = "QueryVMotionCompatibilityEx_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityEx_Task") - kw["aname"] = "_QueryVMotionCompatibilityEx_Task" - if ns0.QueryVMotionCompatibilityExRequestType_Def not in ns0.QueryVMotionCompatibilityEx_Task_Dec.__bases__: - bases = list(ns0.QueryVMotionCompatibilityEx_Task_Dec.__bases__) - bases.insert(0, ns0.QueryVMotionCompatibilityExRequestType_Def) - ns0.QueryVMotionCompatibilityEx_Task_Dec.__bases__ = tuple(bases) - - ns0.QueryVMotionCompatibilityExRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "QueryVMotionCompatibilityEx_Task_Dec_Holder" - - class QueryVMotionCompatibilityEx_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "QueryVMotionCompatibilityEx_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.QueryVMotionCompatibilityEx_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","QueryVMotionCompatibilityEx_TaskResponse") - kw["aname"] = "_QueryVMotionCompatibilityEx_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "QueryVMotionCompatibilityEx_TaskResponse_Holder" - self.pyclass = Holder - - class CheckMigrate_Dec(ElementDeclaration): - literal = "CheckMigrate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckMigrate") - kw["aname"] = "_CheckMigrate" - if ns0.CheckMigrateRequestType_Def not in ns0.CheckMigrate_Dec.__bases__: - bases = list(ns0.CheckMigrate_Dec.__bases__) - bases.insert(0, ns0.CheckMigrateRequestType_Def) - ns0.CheckMigrate_Dec.__bases__ = tuple(bases) - - ns0.CheckMigrateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckMigrate_Dec_Holder" - - class CheckMigrateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckMigrateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckMigrateResponse_Dec.schema - TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckMigrateResponse") - kw["aname"] = "_CheckMigrateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "CheckMigrateResponse_Holder" - self.pyclass = Holder - - class CheckMigrate_Task_Dec(ElementDeclaration): - literal = "CheckMigrate_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckMigrate_Task") - kw["aname"] = "_CheckMigrate_Task" - if ns0.CheckMigrateRequestType_Def not in ns0.CheckMigrate_Task_Dec.__bases__: - bases = list(ns0.CheckMigrate_Task_Dec.__bases__) - bases.insert(0, ns0.CheckMigrateRequestType_Def) - ns0.CheckMigrate_Task_Dec.__bases__ = tuple(bases) - - ns0.CheckMigrateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckMigrate_Task_Dec_Holder" - - class CheckMigrate_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckMigrate_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckMigrate_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckMigrate_TaskResponse") - kw["aname"] = "_CheckMigrate_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CheckMigrate_TaskResponse_Holder" - self.pyclass = Holder - - class CheckRelocate_Dec(ElementDeclaration): - literal = "CheckRelocate" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckRelocate") - kw["aname"] = "_CheckRelocate" - if ns0.CheckRelocateRequestType_Def not in ns0.CheckRelocate_Dec.__bases__: - bases = list(ns0.CheckRelocate_Dec.__bases__) - bases.insert(0, ns0.CheckRelocateRequestType_Def) - ns0.CheckRelocate_Dec.__bases__ = tuple(bases) - - ns0.CheckRelocateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckRelocate_Dec_Holder" - - class CheckRelocateResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckRelocateResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckRelocateResponse_Dec.schema - TClist = [GTD("urn:vim25","CheckResult",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckRelocateResponse") - kw["aname"] = "_CheckRelocateResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = [] - return - Holder.__name__ = "CheckRelocateResponse_Holder" - self.pyclass = Holder - - class CheckRelocate_Task_Dec(ElementDeclaration): - literal = "CheckRelocate_Task" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","CheckRelocate_Task") - kw["aname"] = "_CheckRelocate_Task" - if ns0.CheckRelocateRequestType_Def not in ns0.CheckRelocate_Task_Dec.__bases__: - bases = list(ns0.CheckRelocate_Task_Dec.__bases__) - bases.insert(0, ns0.CheckRelocateRequestType_Def) - ns0.CheckRelocate_Task_Dec.__bases__ = tuple(bases) - - ns0.CheckRelocateRequestType_Def.__init__(self, **kw) - if self.pyclass is not None: self.pyclass.__name__ = "CheckRelocate_Task_Dec_Holder" - - class CheckRelocate_TaskResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration): - literal = "CheckRelocate_TaskResponse" - schema = "urn:vim25" - def __init__(self, **kw): - ns = ns0.CheckRelocate_TaskResponse_Dec.schema - TClist = [GTD("urn:vim25","ManagedObjectReference",lazy=True)(pname=(ns,"returnval"), aname="_returnval", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))] - kw["pname"] = ("urn:vim25","CheckRelocate_TaskResponse") - kw["aname"] = "_CheckRelocate_TaskResponse" - self.attribute_typecode_dict = {} - ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw) - class Holder: - __metaclass__ = pyclass_type - typecode = self - def __init__(self): - # pyclass - self._returnval = None - return - Holder.__name__ = "CheckRelocate_TaskResponse_Holder" - self.pyclass = Holder - - class versionURI_Dec(ZSI.TC.String, ElementDeclaration): - literal = "versionURI" - schema = "urn:vim25" - def __init__(self, **kw): - kw["pname"] = ("urn:vim25","versionURI") - kw["aname"] = "_versionURI" - class IHolder(str): typecode=self - kw["pyclass"] = IHolder - IHolder.__name__ = "_versionURI_immutable_holder" - ZSI.TC.String.__init__(self, **kw) - -# end class ns0 (tns: urn:vim25) diff --git a/nova/virt/vmwareapi_blockdiagram.jpg b/nova/virt/vmwareapi_blockdiagram.jpg deleted file mode 100644 index 1ae1fc8e0..000000000 Binary files a/nova/virt/vmwareapi_blockdiagram.jpg and /dev/null differ diff --git a/nova/virt/vmwareapi_readme.rst b/nova/virt/vmwareapi_readme.rst deleted file mode 100644 index 4e722674b..000000000 --- a/nova/virt/vmwareapi_readme.rst +++ /dev/null @@ -1,72 +0,0 @@ -.. - - Copyright (c) 2010 Citrix Systems, Inc. - Copyright 2010 OpenStack LLC. - - Licensed under the Apache License, Version 2.0 (the "License"); you may - not use this file except in compliance with the License. You may obtain - a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - License for the specific language governing permissions and limitations - under the License. - -VMWare ESX/ESXi Server Support for OpenStack Compute -==================================================== - -System Requirements -------------------- -Following software components are required for building the cloud using OpenStack on top of ESX/ESXi Server(s): -* OpenStack (Bexar Release) -* Glance Image service (Bexar Release) -* VMware ESX v4.1 or VMware ESXi(licensed) v4.1 - -VMware ESX Requirements ------------------------ -* ESX credentials with administration/root privileges -* Single local hard disk at the ESX host -* An ESX Virtual Machine Port Group (Bridge for Flat Networking) - -Python dependencies -------------------- -* ZSI-2.0 - -Configuration flags required for nova-compute ---------------------------------------------- -:: - --connection_type=vmwareapi - --vmwareapi_host_ip= - --vmwareapi_host_username= - --vmwareapi_host_password= - -Other flags ------------ -:: - --network_manager=nova.network.manager.FlatManager - --flat_network_bridge= - --image_service=nova.image.glance.GlanceImageService - --glance_host= - -FAQ ---- - -What type of disk images are supported? - - Only VMware VMDK's are currently supported and of that support is available only for thick disks, thin provisioned disks are not supported. - - -How is IP address information injected into the guest? - - IP address information is injected through 'machine.id' vmx parameter (equivalent to XenStore in XenServer). - This information can be retrived inside the guest using VMware tools. - - -What is the guest tool? - - The guest tool is a small python script that should be run either as a service or added to system startup. This script configures networking on the guest. - - -- cgit From ac5a1cfb0dbcebd36e7cbaab20795d03d523afee Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 21 Feb 2011 11:20:03 -0600 Subject: Stub out VM create --- nova/virt/xenapi/vmops.py | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 4f3468f8e..ac09179a3 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -27,6 +27,7 @@ import tempfile import uuid from nova import db +from nova import compute from nova import context from nova import log as logging from nova import exception @@ -49,6 +50,8 @@ class VMOps(object): def __init__(self, session): self.XenAPI = session.get_imported_xenapi() self._session = session + self.compute_api = compute.API() + VMHelper.XenAPI = self.XenAPI def list_instances(self): @@ -364,21 +367,31 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" vm = self._get_vm_opaque_ref(instance) - target_vm = VMHelper.lookup(self._session, "instance-00000012") - - self._shutdown(instance, vm) - vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] - vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] - vbd_ref = VMHelper.create_vbd( - self._session, - target_vm, - vdi_ref, - 1, - False) + #self._shutdown(instance, vm) + #target_vm = VMHelper.lookup(self._session, "instance-00000012") + target_vm = self.compute_api.create( + context=context.get_admin_context(), + instance_type="m1.tiny", + image_id=1, + kernel_id=3, + ramdisk_id=2, + display_name="test", + display_description="test") + print context.get_admin_context().__dict__ + print target_vm + + #vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] + #vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] + #vbd_ref = VMHelper.create_vbd( + # self._session, + # target_vm, + # vdi_ref, + # 1, + # False) # Plug the VBD into the target instance - self._session.call_xenapi("Async.VBD.plug", vbd_ref) + #self._session.call_xenapi("Async.VBD.plug", vbd_ref) def unrescue(self, instance, callback): """Unrescue the specified instance""" -- cgit From 78ed840ef2f7066c638a76cc3192fec2f93d8450 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 21 Feb 2011 12:48:34 -0600 Subject: Enable rescue testing --- nova/virt/xenapi/vmops.py | 51 ++++++++++++++++++++++++----------------------- 1 file changed, 26 insertions(+), 25 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3c9fd7d31..bd57dc9a1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -406,8 +406,8 @@ class VMOps(object): if ramdisk: args['ramdisk-file'] = ramdisk task2 = self._session.async_call_plugin('glance', fn, args) - self._session.wait_for_task(instance.id, task1) - self._session.wait_for_task(instance.id, task2) + self._session.wait_for_task(task1, instance.id) + self._session.wait_for_task(task2, instance.id) LOG.debug(_("kernel/ramdisk files removed")) except self.XenAPI.Failure, exc: LOG.exception(exc) @@ -477,35 +477,36 @@ class VMOps(object): """Rescue the specified instance""" vm = self._get_vm_opaque_ref(instance) - #self._shutdown(instance, vm) - #target_vm = VMHelper.lookup(self._session, "instance-00000012") - target_vm = self.compute_api.create( - context=context.get_admin_context(), - instance_type="m1.tiny", - image_id=1, - kernel_id=3, - ramdisk_id=2, - display_name="test", - display_description="test") - print context.get_admin_context().__dict__ - print target_vm - - #vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] - #vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] - #vbd_ref = VMHelper.create_vbd( - # self._session, - # target_vm, - # vdi_ref, - # 1, - # False) + self._shutdown(instance, vm) + target_vm = VMHelper.lookup(self._session, "instance-00000001") + #target_vm = self.compute_api.create( + # context=context.get_admin_context(), + # instance_type="m1.tiny", + # image_id=1, + # kernel_id=3, + # ramdisk_id=2, + # display_name="test", + # display_description="test") + #print context.get_admin_context().__dict__ + #print target_vm + + vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] + vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] + vbd_ref = VMHelper.create_vbd( + self._session, + target_vm, + vdi_ref, + 1, + False) # Plug the VBD into the target instance - #self._session.call_xenapi("Async.VBD.plug", vbd_ref) + self._session.call_xenapi("Async.VBD.plug", vbd_ref) + pass def unrescue(self, instance, callback): """Unrescue the specified instance""" vm = self._get_vm_opaque_ref(instance) - target_vm = VMHelper.lookup(self._session, "instance-00000012") + target_vm = VMHelper.lookup(self._session, "instance-00000001") vbds = self._session.get_xenapi().VM.get_VBDs(target_vm) -- cgit From c32e57999be09368b18f5a89315465e629ed4819 Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Tue, 22 Feb 2011 23:55:03 +0900 Subject: Fixed based on reviewer's comment. 1. Change docstrings format 2. Fix comment grammer mistake, etc --- nova/virt/fake.py | 74 ++++--------------- nova/virt/libvirt_conn.py | 182 +++++++++++++++++++++++++++++++++------------- nova/virt/xenapi_conn.py | 14 ++-- 3 files changed, 150 insertions(+), 120 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 70ddd3aaf..069a424d1 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -326,59 +326,6 @@ class FakeConnection(object): 'username': 'fakeuser', 'password': 'fakepassword'} - def get_cpu_info(self): - """This method is supported only libvirt. """ - return - - def get_vcpu_total(self): - """This method is supported only libvirt. """ - return - - def get_memory_mb_total(self): - """This method is supported only libvirt. """ - return - - def get_local_gb_total(self): - """This method is supported only libvirt. """ - return - - def get_vcpu_used(self): - """This method is supported only libvirt. """ - return - - def get_memory_mb_used(self): - """This method is supported only libvirt. """ - return - - def get_local_gb_used(self): - """This method is supported only libvirt. """ - return - - def get_hypervisor_type(self): - """This method is supported only libvirt..""" - return - - def get_hypervisor_version(self): - """This method is supported only libvirt..""" - return - - def compare_cpu(self, xml): - """This method is supported only libvirt..""" - raise NotImplementedError('This method is supported only libvirt.') - - def ensure_filtering_rules_for_instance(self, instance_ref): - """This method is supported only libvirt..""" - return - - def live_migration(self, context, instance_ref, dest, - post_method, recover_method): - """This method is supported only libvirt..""" - return - - def unfilter_instance(self, instance_ref): - """This method is supported only libvirt..""" - raise NotImplementedError('This method is supported only libvirt.') - def refresh_security_group_rules(self, security_group_id): """This method is called after a change to security groups. @@ -428,20 +375,25 @@ class FakeConnection(object): return True def update_available_resource(self, ctxt, host): - """This method is supported only libvirt. """ + """This method is supported only by libvirt.""" return def compare_cpu(self, xml): - """This method is supported only libvirt..""" - raise NotImplementedError('This method is supported only libvirt.') + """This method is supported only by libvirt.""" + raise NotImplementedError('This method is supported only by libvirt.') def ensure_filtering_rules_for_instance(self, instance_ref): - """This method is supported only libvirt..""" - raise NotImplementedError('This method is supported only libvirt.') + """This method is supported only by libvirt.""" + raise NotImplementedError('This method is supported only by libvirt.') + + def live_migration(self, context, instance_ref, dest, + post_method, recover_method): + """This method is supported only by libvirt.""" + return - def live_migration(self, context, instance_ref, dest): - """This method is supported only libvirt..""" - raise NotImplementedError('This method is supported only libvirt.') + def unfilter_instance(self, instance_ref): + """This method is supported only by libvirt.""" + raise NotImplementedError('This method is supported only by libvirt.') class FakeInstance(object): diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index d39836e72..934aed960 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -36,7 +36,6 @@ Supports KVM, QEMU, UML, and XEN. """ -import json import os import shutil import random @@ -105,7 +104,7 @@ flags.DEFINE_string('firewall_driver', 'Firewall driver (defaults to iptables)') flags.DEFINE_string('cpuinfo_xml_template', utils.abspath('virt/cpuinfo.xml.template'), - 'CpuInfo XML Template (used only live migration now)') + 'CpuInfo XML Template (Used only live migration now)') flags.DEFINE_string('live_migration_uri', "qemu+tcp://%s/system", 'Define protocol used by live_migration feature') @@ -851,23 +850,46 @@ class LibvirtConnection(object): return interfaces def get_vcpu_total(self): - """ Get vcpu number of physical computer. """ + """Get vcpu number of physical computer. + + :returns: the number of cpu core. + + """ + return open('/proc/cpuinfo').read().count('processor') def get_memory_mb_total(self): - """Get the total memory size(MB) of physical computer .""" + """Get the total memory size(MB) of physical computer. + + :returns: the total amount of memory(MB). + + """ + meminfo = open('/proc/meminfo').read().split() idx = meminfo.index('MemTotal:') # transforming kb to mb. return int(meminfo[idx + 1]) / 1024 def get_local_gb_total(self): - """Get the total hdd size(GB) of physical computer .""" + """Get the total hdd size(GB) of physical computer. + + :returns: + The total amount of HDD(GB). + Note that this value shows a partition where + NOVA-INST-DIR/instances mounts. + + """ + hddinfo = os.statvfs(FLAGS.instances_path) return hddinfo.f_frsize * hddinfo.f_blocks / 1024 / 1024 / 1024 def get_vcpu_used(self): - """ Get vcpu available number of physical computer. """ + """ Get vcpu usage number of physical computer. + + :returns: The total number of vcpu that currently used. + + """ + total = 0 for i in self._conn.listDomainsID(): dom = self._conn.lookupByID(i) @@ -875,7 +897,12 @@ class LibvirtConnection(object): return total def get_memory_mb_used(self): - """Get the free memory size(MB) of physical computer.""" + """Get the free memory size(MB) of physical computer. + + :returns: the total usage of memory(MB). + + """ + m = open('/proc/meminfo').read().split() idx1 = m.index('MemFree:') idx2 = m.index('Buffers:') @@ -884,21 +911,47 @@ class LibvirtConnection(object): return self.get_memory_mb_total() - avail def get_local_gb_used(self): - """Get the free hdd size(GB) of physical computer .""" + """Get the free hdd size(GB) of physical computer. + + :returns: + The total usage of HDD(GB). + Note that this value shows a partition where + NOVA-INST-DIR/instances mounts. + + """ + hddinfo = os.statvfs(FLAGS.instances_path) avail = hddinfo.f_frsize * hddinfo.f_bavail / 1024 / 1024 / 1024 return self.get_local_gb_total() - avail def get_hypervisor_type(self): - """ Get hypervisor type """ + """Get hypervisor type. + + :returns: hypervisor type (ex. qemu) + + """ + return self._conn.getType() def get_hypervisor_version(self): - """ Get hypervisor version """ + """Get hypervisor version. + + :returns: hypervisor version (ex. 12003) + + """ + return self._conn.getVersion() def get_cpu_info(self): - """ Get cpuinfo information """ + """Get cpuinfo information. + + Obtains cpu feature from virConnect.getCapabilities, + and returns as a json string. + + :return: see above description + + """ + xml = self._conn.getCapabilities() xml = libxml2.parseDoc(xml) nodes = xml.xpathEval('//cpu') @@ -931,17 +984,9 @@ class LibvirtConnection(object): for nodes in feature_nodes: features.append(nodes.get_properties().getContent()) - template = ("""{"arch":"%s", "model":"%s", "vendor":"%s", """ - """"topology":{"cores":"%s", "threads":"%s", """ - """"sockets":"%s"}, "features":[%s]}""") - f = ['"%s"' % x for x in features] - return template % (cpu_info['arch'], - cpu_info['model'], - cpu_info['vendor'], - topology['cores'], - topology['sockets'], - topology['threads'], - ', '.join(f)) + cpu_info['topology'] = topology + cpu_info['features'] = features + return utils.dumps(cpu_info) def block_stats(self, instance_name, disk): """ @@ -974,12 +1019,16 @@ class LibvirtConnection(object): self.firewall_driver.refresh_security_group_members(security_group_id) def update_available_resource(self, ctxt, host): - """ - Update compute manager resource info on Service table. + """Updates compute manager resource info on ComputeService table. + This method is called when nova-coompute launches, and whenever admin executes "nova-manage service update_resource". + :param ctxt: security context + :param host: hostname that compute manager is currently running + """ + try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: @@ -1008,44 +1057,44 @@ class LibvirtConnection(object): db.compute_service_update(ctxt, compute_service_ref[0]['id'], dic) def compare_cpu(self, cpu_info): - """ - Check the host cpu is compatible to a cpu given by xml. + """Checks the host cpu is compatible to a cpu given by xml. + "xml" must be a part of libvirt.openReadonly().getCapabilities(). return values follows by virCPUCompareResult. if 0 > return value, do live migration. - 'http://libvirt.org/html/libvirt-libvirt.html#virCPUCompareResult' + + :param cpu_info: json string that shows cpu feature(see get_cpu_info()) + :returns: + None. if given cpu info is not compatible to this server, + raise exception. + """ - msg = _('Checking cpu_info: instance was launched this cpu.\n: %s ') - LOG.info(msg % cpu_info) - dic = json.loads(cpu_info) - xml = str(Template(self.cpuinfo_xml, searchList=dic)) - msg = _('to xml...\n: %s ') - LOG.info(msg % xml) - url = 'http://libvirt.org/html/libvirt-libvirt.html' - url += '#virCPUCompareResult\n' - msg = 'CPU does not have compativility.\n' - msg += 'result:%s \n' - msg += 'Refer to %s' - msg = _(msg) + LOG.info(_('Checking cpu_info: instance was launched this cpu.\n%s') + % cpu_info) + dic = utils.loads(cpu_info) + xml = str(Template(self.cpuinfo_xml, searchList=dic)) + LOG.info(_('to xml...\n:%s ' % xml)) + u = "http://libvirt.org/html/libvirt-libvirt.html#virCPUCompareResult" + m = _("CPU doesn't have compatibility.\n\n%(ret)s\n\nRefer to %(u)s") # unknown character exists in xml, then libvirt complains try: ret = self._conn.compareCPU(xml, 0) except libvirt.libvirtError, e: - LOG.error(msg % (e.message, url)) - raise e + ret = e.message + LOG.error(m % locals()) + raise if ret <= 0: - raise exception.Invalid(msg % (ret, url)) + raise exception.Invalid(m % locals()) return def ensure_filtering_rules_for_instance(self, instance_ref): - """ - Setting up inevitable filtering rules on compute node, - and waiting for its completion. + """Setting up filtering rules and waiting for its completion. + To migrate an instance, filtering rules to hypervisors and firewalls are inevitable on destination host. ( Waiting only for filterling rules to hypervisor, @@ -1062,9 +1111,12 @@ class LibvirtConnection(object): Don't use thread for this method since migration should not be started when setting-up filtering rules operations are not completed. + + :params instance_ref: nova.db.sqlalchemy.models.Instance object + """ - # Tf any instances never launch at destination host, + # If any instances never launch at destination host, # basic-filtering must be set here. self.firewall_driver.setup_basic_filtering(instance_ref) # setting up n)ova-instance-instance-xx mainly. @@ -1088,16 +1140,42 @@ class LibvirtConnection(object): def live_migration(self, ctxt, instance_ref, dest, post_method, recover_method): + """Spawning live_migration operation for distributing high-load. + + :params ctxt: security context + :params instance_ref: + nova.db.sqlalchemy.models.Instance object + instance object that is migrated. + :params dest: destination host + :params post_method: + post operation method. + expected nova.compute.manager.post_live_migration. + :params recover_method: + recovery method when any exception occurs. + expected nova.compute.manager.recover_live_migration. + """ - Just spawning live_migration operation for - distributing high-load. - """ + greenthread.spawn(self._live_migration, ctxt, instance_ref, dest, post_method, recover_method) def _live_migration(self, ctxt, instance_ref, dest, post_method, recover_method): - """ Do live migration.""" + """Do live migration. + + :params ctxt: security context + :params instance_ref: + nova.db.sqlalchemy.models.Instance object + instance object that is migrated. + :params dest: destination host + :params post_method: + post operation method. + expected nova.compute.manager.post_live_migration. + :params recover_method: + recovery method when any exception occurs. + expected nova.compute.manager.recover_live_migration. + + """ # Do live migration. try: @@ -1122,7 +1200,7 @@ class LibvirtConnection(object): except Exception, e: recover_method(ctxt, instance_ref) - raise e + raise # Waiting for completion of live_migration. timer = utils.LoopingCall(f=None) @@ -1139,7 +1217,7 @@ class LibvirtConnection(object): timer.start(interval=0.5, now=True) def unfilter_instance(self, instance_ref): - """See comments of same method in firewall_driver""" + """See comments of same method in firewall_driver.""" self.firewall_driver.unfilter_instance(instance_ref) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 3dd7d6e94..0e12a4587 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -231,25 +231,25 @@ class XenAPIConnection(object): 'password': FLAGS.xenapi_connection_password} def update_available_resource(self, ctxt, host): - """This method is supported only libvirt. """ + """This method is supported only by libvirt.""" return def compare_cpu(self, xml): - """This method is supported only libvirt..""" - raise NotImplementedError('This method is supported only libvirt.') + """This method is supported only by libvirt.""" + raise NotImplementedError('This method is supported only by libvirt.') def ensure_filtering_rules_for_instance(self, instance_ref): - """This method is supported only libvirt..""" + """This method is supported only libvirt.""" return def live_migration(self, context, instance_ref, dest, post_method, recover_method): - """This method is supported only libvirt..""" + """This method is supported only by libvirt.""" return def unfilter_instance(self, instance_ref): - """This method is supported only libvirt..""" - raise NotImplementedError('This method is supported only libvirt.') + """This method is supported only by libvirt.""" + raise NotImplementedError('This method is supported only by libvirt.') class XenAPISession(object): -- cgit From c6b2d07f47004576fa386a6d270203b1d7937664 Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Wed, 23 Feb 2011 00:15:39 +0900 Subject: Fix tiny mitakes! (remove unnecessary comment, etc) --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 934aed960..118ea13e5 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -888,7 +888,7 @@ class LibvirtConnection(object): :returns: The total number of vcpu that currently used. - """ + """ total = 0 for i in self._conn.listDomainsID(): -- cgit From 20113ae3dcb4b7cd914a0e0862240b08bb855735 Mon Sep 17 00:00:00 2001 From: sateesh Date: Tue, 22 Feb 2011 21:14:58 +0530 Subject: Updated import statements according to HACKING guidelines. Added docstrings to each document. Verified pep8 over all files. Replaced some constants by enums accordingly. Still little bit more left in vm_util.py and vim_util.py files. --- nova/virt/vmwareapi/__init__.py | 16 +++++++++++++ nova/virt/vmwareapi/io_util.py | 21 ++++++++++++----- nova/virt/vmwareapi/read_write_util.py | 14 ++++++++++-- nova/virt/vmwareapi/vim.py | 8 ++++++- nova/virt/vmwareapi/vim_util.py | 2 ++ nova/virt/vmwareapi/vm_util.py | 5 +++++ nova/virt/vmwareapi/vmops.py | 9 +++++--- nova/virt/vmwareapi/vmware_images.py | 21 ++++++++++------- nova/virt/vmwareapi_conn.py | 41 +++++++++++++++++++++++++++++----- 9 files changed, 112 insertions(+), 25 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/__init__.py b/nova/virt/vmwareapi/__init__.py index e9c06d96a..52e3ddf4d 100644 --- a/nova/virt/vmwareapi/__init__.py +++ b/nova/virt/vmwareapi/__init__.py @@ -14,3 +14,19 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. + +""" +:mod:`vmwareapi` -- Nova support for VMware ESX/ESXi Server through vSphere API +=============================================================================== +""" + + +class HelperBase(object): + """ + The base for helper classes. This adds the VMwareAPI class attribute + """ + + VMwareAPI = None + + def __init__(self): + return diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py index 48ea4debf..3b3cbee33 100644 --- a/nova/virt/vmwareapi/io_util.py +++ b/nova/virt/vmwareapi/io_util.py @@ -16,15 +16,24 @@ # under the License. """ - Reads a chunk from input file and writes the same to the output file till - it reaches the transferable size. +Helper classes for multi-threaded I/O (read/write) in the basis of chunks. + +The class ThreadSafePipe queues the chunk data. + +The class IOThread reads chunks from input file and pipes it to output file +till it reaches the transferable size + """ -from Queue import Queue, Full, Empty +from Queue import Empty +from Queue import Full +from Queue import Queue from threading import Thread import time import traceback +THREAD_SLEEP_TIME = .01 + class ThreadSafePipe(Queue): """ @@ -122,12 +131,12 @@ class IOThread(Thread): # no more data in read break #Restrict tight loop - time.sleep(.01) + time.sleep(THREAD_SLEEP_TIME) except Full: # Pipe full while writing to pipe - safe to retry since #chunk is preserved #Restrict tight loop - time.sleep(.01) + time.sleep(THREAD_SLEEP_TIME) if isinstance(self.output_file, ThreadSafePipe): # If this is the reader thread, send eof signal self.output_file.set_eof(True) @@ -137,7 +146,7 @@ class IOThread(Thread): raise IOError("Not enough data (%d of %d bytes)" \ % (self.read_size, self.transfer_size)) - except: + except Exception: self._error = True self._exception = str(traceback.format_exc()) self._done = True diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py index c3eeb0566..fcd95308a 100644 --- a/nova/virt/vmwareapi/read_write_util.py +++ b/nova/virt/vmwareapi/read_write_util.py @@ -15,6 +15,16 @@ # License for the specific language governing permissions and limitations # under the License. +""" Image file handlers + +Collection of classes to handle image upload/download to/from Image service +(like Glance image storage and retrieval service) from/to ESX/ESXi server. + +Also a class is available that acts as Fake image service. It uses local +file system for storage. + +""" + import httplib import json import logging @@ -84,7 +94,7 @@ class ImageServiceFile: """ try: self.file_handle.close() - except: + except Exception: pass def get_image_properties(self): @@ -267,7 +277,7 @@ class VMwareHTTPFile(object): """ try: self.file_handle.close() - except: + except Exception: pass def __del__(self): diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index 03439a049..3007535dd 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -15,9 +15,15 @@ # License for the specific language governing permissions and limitations # under the License. -import ZSI +""" +Class facilitating SOAP calls to ESX/ESXi server + +""" + import httplib +import ZSI + from nova.virt.vmwareapi import VimService_services RESP_NOT_XML_ERROR = 'Response is "text/html", not "text/xml' diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py index 8596a1004..d38d8b949 100644 --- a/nova/virt/vmwareapi/vim_util.py +++ b/nova/virt/vmwareapi/vim_util.py @@ -17,7 +17,9 @@ """ The VMware API utility module + """ + from nova.virt.vmwareapi.VimService_services_types import ns0 MAX_CLONE_RETRIES = 1 diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py index 603537278..b1202f2b1 100644 --- a/nova/virt/vmwareapi/vm_util.py +++ b/nova/virt/vmwareapi/vm_util.py @@ -15,6 +15,11 @@ # License for the specific language governing permissions and limitations # under the License. +""" +Utility functions to handle virtual disks, virtual network adapters, VMs etc. + +""" + from nova.virt.vmwareapi.VimService_services_types import ns0 diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index 23247a54e..4eda4ef0e 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -15,6 +15,10 @@ # License for the specific language governing permissions and limitations # under the License. +""" +Class for VM tasks like spawn, snapshot, suspend, resume etc. + +""" import logging import os import time @@ -23,7 +27,6 @@ import uuid from nova import db from nova import context from nova.compute import power_state - from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi import vm_util from nova.virt.vmwareapi import vmware_images @@ -102,8 +105,8 @@ class VMWareVMOps(object): 'but that already exists on the host' % instance.name) bridge = db.network_get_by_instance(context.get_admin_context(), instance['id'])['bridge'] - #TODO: Shouldn't we consider any public network in case the network - #name supplied isn't there + #TODO(sateesh): Shouldn't we consider any public network in case + #the network name supplied isn't there network_ref = \ self._get_network_with_the_name(bridge) if network_ref is None: diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py index aa3b263cd..d3b1dc446 100644 --- a/nova/virt/vmwareapi/vmware_images.py +++ b/nova/virt/vmwareapi/vmware_images.py @@ -15,12 +15,16 @@ # License for the specific language governing permissions and limitations # under the License. -import time -import os +""" +Utility functions to handle vm images. Also include fake image handlers. + +""" + import logging +import os +import time from nova import flags - from nova.virt.vmwareapi import read_write_util from nova.virt.vmwareapi import io_util @@ -31,6 +35,7 @@ READ_CHUNKSIZE = 2 * 1024 * 1024 WRITE_CHUNKSIZE = 2 * 1024 * 1024 LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images") +TEST_IMAGE_PATH = "/tmp/vmware-test-images" def start_transfer(read_file_handle, write_file_handle, data_size): @@ -148,7 +153,7 @@ def _get_fake_image(image, instance, **kwargs): """ LOG.debug("Downloading image %s from fake image service" % image) image = str(image) - file_path = os.path.join("/tmp/vmware-test-images", image, image) + file_path = os.path.join(TEST_IMAGE_PATH, image, image) file_path = os.path.abspath(file_path) read_file_handle = read_write_util.FakeFileRead(file_path) file_size = read_file_handle.get_size() @@ -215,9 +220,9 @@ def _put_fake_image(image, instance, **kwargs): kwargs.get("file_path")) file_size = read_file_handle.get_size() image = str(image) - image_dir_path = os.path.join("/tmp/vmware-test-images", image) - if not os.path.exists("/tmp/vmware-test-images"): - os.mkdir("/tmp/vmware-test-images") + image_dir_path = os.path.join(TEST_IMAGE_PATH, image) + if not os.path.exists(TEST_IMAGE_PATH): + os.mkdir(TEST_IMAGE_PATH) os.mkdir(image_dir_path) else: if not os.path.exists(image_dir_path): @@ -247,7 +252,7 @@ def get_vmdk_size_and_properties(image, instance): raise NotImplementedError elif FLAGS.image_service == "nova.FakeImageService": image = str(image) - file_path = os.path.join("/tmp/vmware-test-images", image, image) + file_path = os.path.join(TEST_IMAGE_PATH, image, image) file_path = os.path.abspath(file_path) read_file_handle = read_write_util.FakeFileRead(file_path) size = read_file_handle.get_size() diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index d53a1c129..421efe91c 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -15,6 +15,23 @@ # License for the specific language governing permissions and limitations # under the License. +""" +Connection class for VMware Infrastructure API in VMware ESX/ESXi platform + +Encapsulates the session management activties and acts as interface for VI API. +The connection class sets up a session with the ESX/ESXi compute provider host +and handles all the calls made to the host. + +**Related Flags** + +:vmwareapi_host_ip: IP of VMware ESX/ESXi compute provider host +:vmwareapi_host_username: ESX/ESXi server user to be used for API session +:vmwareapi_host_password: Password for the user "vmwareapi_host_username" +:vmwareapi_task_poll_interval: The interval used for polling of remote tasks +:vmwareapi_api_retry_count: Max number of retry attempts upon API failures + +""" + import logging import time import urlparse @@ -58,6 +75,19 @@ flags.DEFINE_float('vmwareapi_api_retry_count', TIME_BETWEEN_API_CALL_RETRIES = 2.0 +class TaskState: + """ + Enumeration class for different states of task + 0 - Task completed successfully + 1 - Task is in queued state + 2 - Task is in running state + """ + + TASK_SUCCESS = 0 + TASK_QUEUED = 1 + TASK_RUNNING = 2 + + class Failure(Exception): """ Base Exception class for handling task failures @@ -278,7 +308,7 @@ class VMWareAPISession(object): # ESX host try: self.vim.Logout(self.vim.get_service_content().SessionManager) - except: + except Exception: pass def _call_method(self, module, method, *args, **kwargs): @@ -363,17 +393,18 @@ class VMWareAPISession(object): instance_id=int(instance_id), action=task_name[0:255], error=None) - if task_info.State in ['queued', 'running']: + if task_info.State in [TaskState.TASK_QUEUED, + TaskState.TASK_RUNNING]: return - elif task_info.State == 'success': + elif task_info.State == TaskState.TASK_SUCCESS: LOG.info("Task [%s] %s status: success " % ( task_name, str(task_ref))) - done.send("success") + done.send(TaskState.TASK_SUCCESS) else: error_info = str(task_info.Error.LocalizedMessage) action["error"] = error_info - LOG.warn("Task [%s] %s status: error %s" % ( + LOG.warn("Task [%s] %s status: error [%s]" % ( task_name, str(task_ref), error_info)) -- cgit From d1a6cb96c1c72894cbba24e6806da5c81fb915df Mon Sep 17 00:00:00 2001 From: Ewan Mellor Date: Tue, 22 Feb 2011 20:39:33 +0000 Subject: Removed block of code that resurrected itself in the last merge. --- nova/virt/xenapi/vmops.py | 4 ---- 1 file changed, 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 1b2712d15..c9cc8e698 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -108,10 +108,6 @@ class VMOps(object): instance, kernel, ramdisk, pv_kernel) VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) - if network_ref: - VMHelper.create_vif(self._session, vm_ref, - network_ref, instance.mac_address) - # Alter the image before VM start for, e.g. network injection VMHelper.preconfigure_instance(self._session, instance, vdi_ref) -- cgit From 943b863bef09a4e2b3de36c26a3fabbcc6093411 Mon Sep 17 00:00:00 2001 From: Vishvananda Ishaya Date: Tue, 22 Feb 2011 23:21:01 -0800 Subject: Lots of test fixing --- nova/virt/fake.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 92749f38a..4346dffc1 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -319,7 +319,9 @@ class FakeConnection(object): return 'FAKE CONSOLE OUTPUT' def get_ajax_console(self, instance): - return 'http://fakeajaxconsole.com/?token=FAKETOKEN' + return {'token': 'FAKETOKEN', + 'host': 'fakeajaxconsole.com', + 'port': 6969} def get_console_pool_info(self, console_type): return {'address': '127.0.0.1', -- cgit From c0d3b8415ed34c6b259e183a047ca37c9598ffd4 Mon Sep 17 00:00:00 2001 From: sateesh Date: Wed, 23 Feb 2011 20:04:53 +0530 Subject: * Took care of localization of strings * Addressed all one liner docstrings * Added Sateesh, Milind to Authors file --- nova/virt/vmwareapi/__init__.py | 5 +- nova/virt/vmwareapi/io_util.py | 44 ++----- nova/virt/vmwareapi/read_write_util.py | 182 +++++++------------------- nova/virt/vmwareapi/vim.py | 74 ++++------- nova/virt/vmwareapi/vim_util.py | 48 ++----- nova/virt/vmwareapi/vm_util.py | 43 ++----- nova/virt/vmwareapi/vmops.py | 226 ++++++++++++++------------------- nova/virt/vmwareapi/vmware_images.py | 74 ++++------- nova/virt/vmwareapi_conn.py | 144 ++++++--------------- 9 files changed, 274 insertions(+), 566 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/__init__.py b/nova/virt/vmwareapi/__init__.py index 52e3ddf4d..0cf70150c 100644 --- a/nova/virt/vmwareapi/__init__.py +++ b/nova/virt/vmwareapi/__init__.py @@ -22,10 +22,7 @@ class HelperBase(object): - """ - The base for helper classes. This adds the VMwareAPI class attribute - """ - + """The base for helper classes. This adds the VMwareAPI class attribute""" VMwareAPI = None def __init__(self): diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py index 3b3cbee33..6761d894c 100644 --- a/nova/virt/vmwareapi/io_util.py +++ b/nova/virt/vmwareapi/io_util.py @@ -36,39 +36,27 @@ THREAD_SLEEP_TIME = .01 class ThreadSafePipe(Queue): - """ - ThreadSafePipe class queue's the chunk data. - """ + """ThreadSafePipe class queue's the chunk data.""" def __init__(self, max_size=None): - """ - Initializes the queue - """ + """Initializes the queue""" Queue.__init__(self, max_size) self.eof = False def write(self, data): - """ - Writes the chunk data to the queue. - """ + """Writes the chunk data to the queue.""" self.put(data, block=False) def read(self): - """ - Retrieves the chunk data from the queue. - """ + """Retrieves the chunk data from the queue.""" return self.get(block=False) def set_eof(self, eof): - """ - Sets EOF to mark reading of input file finishes. - """ + """Sets EOF to mark reading of input file finishes.""" self.eof = eof def get_eof(self): - """ - Returns whether EOF reached. - """ + """Returns whether EOF reached.""" return self.eof @@ -143,8 +131,8 @@ class IOThread(Thread): if not self.transfer_size is None: if self.read_size < self.transfer_size: - raise IOError("Not enough data (%d of %d bytes)" \ - % (self.read_size, self.transfer_size)) + raise IOError(_("Not enough data (%d of %d bytes)") % \ + (self.read_size, self.transfer_size)) except Exception: self._error = True @@ -152,26 +140,18 @@ class IOThread(Thread): self._done = True def stop_io_transfer(self): - """ - Set the stop flag to true, which causes the thread to stop safely. - """ + """Set stop flag to true, which causes the thread to stop safely.""" self._stop_transfer = True self.join() def get_error(self): - """ - Returns the error string. - """ + """Returns the error string.""" return self._error def get_exception(self): - """ - Returns the traceback exception string. - """ + """Returns the traceback exception string.""" return self._exception def is_done(self): - """ - Checks whether transfer is complete. - """ + """Checks whether transfer is complete.""" return self._done diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py index fcd95308a..45214be04 100644 --- a/nova/virt/vmwareapi/read_write_util.py +++ b/nova/virt/vmwareapi/read_write_util.py @@ -15,7 +15,7 @@ # License for the specific language governing permissions and limitations # under the License. -""" Image file handlers +""" Classes to handle image files Collection of classes to handle image upload/download to/from Image service (like Glance image storage and retrieval service) from/to ESX/ESXi server. @@ -47,79 +47,55 @@ LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util") class ImageServiceFile: - """ - The base image service Class - """ + """The base image service Class""" def __init__(self, file_handle): - """ - Initialize the file handle. - """ + """Initialize the file handle.""" self.eof = False self.file_handle = file_handle def write(self, data): - """ - Write data to the file - """ + """Write data to the file""" raise NotImplementedError def read(self, chunk_size=READ_CHUNKSIZE): - """ - Read a chunk of data from the file - """ + """Read a chunk of data from the file""" raise NotImplementedError def get_size(self): - """ - Get the size of the file whose data is to be read - """ + """Get the size of the file whose data is to be read""" raise NotImplementedError def set_eof(self, eof): - """ - Set the end of file marker. - """ + """Set the end of file marker.""" self.eof = eof def get_eof(self): - """ - Check if the file end has been reached or not. - """ + """Check if the file end has been reached or not.""" return self.eof def close(self): - """ - Close the file handle. - """ + """Close the file handle.""" try: self.file_handle.close() except Exception: pass def get_image_properties(self): - """ - Get the image properties - """ + """Get the image properties""" raise NotImplementedError def __del__(self): - """ - Destructor. Close the file handle if the same has been forgotten. - """ + """Destructor. Close the file handle if the same has been forgotten.""" self.close() class GlanceHTTPWriteFile(ImageServiceFile): - """ - Glance file write handler Class - """ + """Glance file write handler Class""" def __init__(self, host, port, image_id, file_size, os_type, adapter_type, version=1, scheme="http"): - """ - Initialize with the glance host specifics. - """ + """Initialize with the glance host specifics.""" base_url = "%s://%s:%s/images/%s" % (scheme, host, port, image_id) (scheme, netloc, path, params, query, fragment) = \ urlparse.urlparse(base_url) @@ -145,21 +121,15 @@ class GlanceHTTPWriteFile(ImageServiceFile): ImageServiceFile.__init__(self, conn) def write(self, data): - """ - Write data to the file - """ + """Write data to the file""" self.file_handle.send(data) class GlanceHTTPReadFile(ImageServiceFile): - """ - Glance file read handler Class - """ + """Glance file read handler Class""" def __init__(self, host, port, image_id, scheme="http"): - """ - Initialize with the glance host specifics. - """ + """Initialize with the glance host specifics.""" base_url = "%s://%s:%s/images/%s" % (scheme, host, port, urllib.pathname2url(image_id)) headers = {'User-Agent': USER_AGENT} @@ -168,21 +138,15 @@ class GlanceHTTPReadFile(ImageServiceFile): ImageServiceFile.__init__(self, conn) def read(self, chunk_size=READ_CHUNKSIZE): - """ - Read a chunk of data. - """ + """Read a chunk of data.""" return self.file_handle.read(chunk_size) def get_size(self): - """ - Get the size of the file to be read. - """ + """Get the size of the file to be read.""" return self.file_handle.headers.get("X-Image-Meta-Size", -1) def get_image_properties(self): - """ - Get the image properties like say OS Type and the Adapter Type - """ + """Get the image properties like say OS Type and the Adapter Type""" return {"vmware_ostype": self.file_handle.headers.get( "X-Image-Meta-Property-Vmware_ostype"), @@ -195,134 +159,94 @@ class GlanceHTTPReadFile(ImageServiceFile): class FakeFileRead(ImageServiceFile): - """ - Local file read handler class - """ + """Local file read handler class""" def __init__(self, path): - """ - Initialize the file path - """ + """Initialize the file path""" self.path = path file_handle = open(path, "rb") ImageServiceFile.__init__(self, file_handle) def get_size(self): - """ - Get size of the file to be read - """ + """Get size of the file to be read""" return os.path.getsize(os.path.abspath(self.path)) def read(self, chunk_size=READ_CHUNKSIZE): - """ - Read a chunk of data - """ + """Read a chunk of data""" return self.file_handle.read(chunk_size) def get_image_properties(self): - """ - Get the image properties like say OS Type and the Adapter Type - """ + """Get the image properties like say OS Type and the Adapter Type""" return {"vmware_ostype": "otherGuest", "vmware_adaptertype": "lsiLogic", "vmware_image_version": "1"} class FakeFileWrite(ImageServiceFile): - """ - Local file write handler Class - """ + """Local file write handler Class""" def __init__(self, path): - """ - Initialize the file path. - """ + """Initialize the file path.""" file_handle = open(path, "wb") ImageServiceFile.__init__(self, file_handle) def write(self, data): - """ - Write data to the file. - """ + """Write data to the file.""" self.file_handle.write(data) class VMwareHTTPFile(object): - """ - Base Class for HTTP file. - """ + """Base Class for HTTP file.""" def __init__(self, file_handle): - """ - Intialize the file handle. - """ + """Intialize the file handle.""" self.eof = False self.file_handle = file_handle def set_eof(self, eof): - """ - Set the end of file marker. - """ + """Set the end of file marker.""" self.eof = eof def get_eof(self): - """ - Check if the end of file has been reached. - """ + """Check if the end of file has been reached.""" return self.eof def close(self): - """ - Close the file handle. - """ + """Close the file handle.""" try: self.file_handle.close() except Exception: pass def __del__(self): - """ - Destructor. Close the file handle if the same has been forgotten. - """ + """Destructor. Close the file handle if the same has been forgotten.""" self.close() def _build_vim_cookie_headers(self, vim_cookies): - """ - Build ESX host session cookie headers. - """ + """Build ESX host session cookie headers.""" cookie = str(vim_cookies).split(":")[1].strip() cookie = cookie[:cookie.find(';')] return cookie def write(self, data): - """ - Write data to the file. - """ + """Write data to the file.""" raise NotImplementedError def read(self, chunk_size=READ_CHUNKSIZE): - """ - Read a chunk of data. - """ + """Read a chunk of data.""" raise NotImplementedError def get_size(self): - """ - Get size of the file to be read. - """ + """Get size of the file to be read.""" raise NotImplementedError class VMWareHTTPWriteFile(VMwareHTTPFile): - """ - VMWare file write handler Class - """ + """VMWare file write handler Class""" def __init__(self, host, data_center_name, datastore_name, cookies, file_path, file_size, scheme="https"): - """ - Initialize the file specifics. - """ + """Initialize the file specifics.""" base_url = "%s://%s/folder/%s" % (scheme, host, file_path) param_list = {"dcPath": data_center_name, "dsName": datastore_name} base_url = base_url + "?" + urllib.urlencode(param_list) @@ -341,33 +265,25 @@ class VMWareHTTPWriteFile(VMwareHTTPFile): VMwareHTTPFile.__init__(self, conn) def write(self, data): - """ - Write to the file. - """ + """Write to the file.""" self.file_handle.send(data) def close(self): - """ - Get the response and close the connection - """ + """Get the response and close the connection""" try: self.conn.getresponse() except Exception, excep: - LOG.debug("Exception during close of connection in " - "VMWareHTTpWrite. Exception is %s" % excep) + LOG.debug(_("Exception during close of connection in " + "VMWareHTTpWrite. Exception is %s") % excep) super(VMWareHTTPWriteFile, self).close() class VmWareHTTPReadFile(VMwareHTTPFile): - """ - VMWare file read handler Class - """ + """VMWare file read handler Class""" def __init__(self, host, data_center_name, datastore_name, cookies, file_path, scheme="https"): - """ - Initialize the file specifics. - """ + """Initialize the file specifics.""" base_url = "%s://%s/folder/%s" % (scheme, host, urllib.pathname2url(file_path)) param_list = {"dcPath": data_center_name, "dsName": datastore_name} @@ -379,13 +295,9 @@ class VmWareHTTPReadFile(VMwareHTTPFile): VMwareHTTPFile.__init__(self, conn) def read(self, chunk_size=READ_CHUNKSIZE): - """ - Read a chunk of data. - """ + """Read a chunk of data.""" return self.file_handle.read(chunk_size) def get_size(self): - """ - Get size of the file to be read. - """ + """Get size of the file to be read.""" return self.file_handle.headers.get("Content-Length", -1) diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index 3007535dd..9aca1b7ae 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -32,50 +32,36 @@ ADDRESS_IN_USE_ERROR = 'Address already in use' class VimException(Exception): - """ - The VIM Exception class - """ + """The VIM Exception class""" def __init__(self, exception_summary, excep): - """ - Initializer - """ + """Initializer""" Exception.__init__(self) self.exception_summary = exception_summary self.exception_obj = excep def __str__(self): - """ - The informal string representation of the object - """ + """The informal string representation of the object""" return self.exception_summary + str(self.exception_obj) class SessionOverLoadException(VimException): - """ - Session Overload Exception - """ + """Session Overload Exception""" pass class SessionFaultyException(VimException): - """ - Session Faulty Exception - """ + """Session Faulty Exception""" pass class VimAttributeError(VimException): - """ - Attribute Error - """ + """Attribute Error""" pass class Vim: - """ - The VIM Object - """ + """The VIM Object""" def __init__(self, protocol="https", @@ -106,15 +92,11 @@ class Vim: self.RetrieveServiceContent("ServiceInstance") def get_service_content(self): - """ - Gets the service content object - """ + """Gets the service content object""" return self._service_content def __getattr__(self, attr_name): - """ - Makes the API calls and gets the result - """ + """Makes the API calls and gets the result""" try: return object.__getattr__(self, attr_name) except AttributeError: @@ -141,40 +123,38 @@ class Vim: except AttributeError, excep: return None except AttributeError, excep: - raise VimAttributeError("No such SOAP method '%s'" - " provided by VI SDK" % (attr_name), excep) + raise VimAttributeError(_("No such SOAP method '%s'" + " provided by VI SDK") % (attr_name), excep) except ZSI.FaultException, excep: - raise SessionFaultyException(" in" - " %s:" % (attr_name), excep) + raise SessionFaultyException(_(" in" + " %s:") % (attr_name), excep) except ZSI.EvaluateException, excep: - raise SessionFaultyException(" in" - " %s:" % (attr_name), excep) + raise SessionFaultyException(_(" in" + " %s:") % (attr_name), excep) except (httplib.CannotSendRequest, httplib.ResponseNotReady, httplib.CannotSendHeader), excep: - raise SessionOverLoadException("httplib errror in" - " %s: " % (attr_name), excep) + raise SessionOverLoadException(_("httplib errror in" + " %s: ") % (attr_name), excep) except Exception, excep: # Socket errors which need special handling for they # might be caused by ESX API call overload if (str(excep).find(ADDRESS_IN_USE_ERROR) != -1 or str(excep).find(CONN_ABORT_ERROR)): - raise SessionOverLoadException("Socket error in" - " %s: " % (attr_name), excep) + raise SessionOverLoadException(_("Socket error in" + " %s: ") % (attr_name), excep) # Type error that needs special handling for it might be # caused by ESX host API call overload elif str(excep).find(RESP_NOT_XML_ERROR) != -1: - raise SessionOverLoadException("Type error in " - " %s: " % (attr_name), excep) + raise SessionOverLoadException(_("Type error in " + " %s: ") % (attr_name), excep) else: raise VimException( - "Exception in %s " % (attr_name), excep) + _("Exception in %s ") % (attr_name), excep) return vim_request_handler def _request_message_builder(self, method_name, managed_object, **kwargs): - """ - Builds the Request Message - """ + """Builds the Request Message""" #Request Message Builder request_msg = getattr(VimService_services, \ method_name + "RequestMsg")() @@ -189,13 +169,9 @@ class Vim: return request_msg def __repr__(self): - """ - The official string representation - """ + """The official string representation""" return "VIM Object" def __str__(self): - """ - The informal string representation - """ + """The informal string representation""" return "VIM Object" diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py index d38d8b949..d07f7c278 100644 --- a/nova/virt/vmwareapi/vim_util.py +++ b/nova/virt/vmwareapi/vim_util.py @@ -26,9 +26,7 @@ MAX_CLONE_RETRIES = 1 def build_recursive_traversal_spec(): - """ - Builds the Traversal Spec - """ + """Builds the Traversal Spec""" #Traversal through "hostFolder" branch visit_folders_select_spec = ns0.SelectionSpec_Def("visitFolders").pyclass() visit_folders_select_spec.set_element_name("visitFolders") @@ -145,9 +143,7 @@ def build_recursive_traversal_spec(): def build_property_spec(type="VirtualMachine", properties_to_collect=["name"], all_properties=False): - """ - Builds the Property Spec - """ + """Builds the Property Spec""" property_spec = ns0.PropertySpec_Def("propertySpec").pyclass() property_spec.set_element_type(type) property_spec.set_element_all(all_properties) @@ -156,9 +152,7 @@ def build_property_spec(type="VirtualMachine", properties_to_collect=["name"], def build_object_spec(root_folder, traversal_specs): - """ - Builds the object Spec - """ + """Builds the object Spec""" object_spec = ns0.ObjectSpec_Def("ObjectSpec").pyclass() object_spec.set_element_obj(root_folder) object_spec.set_element_skip(False) @@ -167,9 +161,7 @@ def build_object_spec(root_folder, traversal_specs): def build_property_filter_spec(property_specs, object_specs): - """ - Builds the Property Filter Spec - """ + """Builds the Property Filter Spec""" property_filter_spec = \ ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() property_filter_spec.set_element_propSet(property_specs) @@ -178,9 +170,7 @@ def build_property_filter_spec(property_specs, object_specs): def get_object_properties(vim, collector, mobj, type, properties): - """ - Gets the properties of the Managed object specified - """ + """Gets the properties of the Managed object specified""" if mobj is None: return None usecoll = collector @@ -203,9 +193,7 @@ def get_object_properties(vim, collector, mobj, type, properties): def get_dynamic_property(vim, mobj, type, property_name): - """ - Gets a particular property of the Managed Object - """ + """Gets a particular property of the Managed Object""" obj_content = \ get_object_properties(vim, None, mobj, type, [property_name]) property_value = None @@ -217,9 +205,7 @@ def get_dynamic_property(vim, mobj, type, property_name): def get_objects(vim, type, properties_to_collect=["name"], all=False): - """ - Gets the list of objects of the type specified - """ + """Gets the list of objects of the type specified""" object_spec = build_object_spec(vim.get_service_content().RootFolder, [build_recursive_traversal_spec()]) property_spec = build_property_spec(type=type, @@ -232,9 +218,7 @@ def get_objects(vim, type, properties_to_collect=["name"], all=False): def get_traversal_spec(type, path, name="traversalSpec"): - """ - Builds the traversal spec object - """ + """Builds the traversal spec object""" t_spec = ns0.TraversalSpec_Def(name).pyclass() t_spec._name = name t_spec._type = type @@ -244,9 +228,7 @@ def get_traversal_spec(type, path, name="traversalSpec"): def get_prop_spec(type, properties): - """ - Builds the Property Spec Object - """ + """Builds the Property Spec Object""" prop_spec = ns0.PropertySpec_Def("PropertySpec").pyclass() prop_spec._type = type prop_spec._pathSet = properties @@ -254,9 +236,7 @@ def get_prop_spec(type, properties): def get_obj_spec(obj, select_set=None): - """ - Builds the Object Spec object - """ + """Builds the Object Spec object""" obj_spec = ns0.ObjectSpec_Def("ObjectSpec").pyclass() obj_spec._obj = obj obj_spec._skip = False @@ -266,9 +246,7 @@ def get_obj_spec(obj, select_set=None): def get_prop_filter_spec(obj_spec, prop_spec): - """ - Builds the Property Filter Spec Object - """ + """Builds the Property Filter Spec Object""" prop_filter_spec = \ ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() prop_filter_spec._propSet = prop_spec @@ -279,8 +257,8 @@ def get_prop_filter_spec(obj_spec, prop_spec): def get_properites_for_a_collection_of_objects(vim, type, obj_list, properties): """ - Gets the list of properties for the collection of - objects of the type specified + Gets the list of properties for the collection of objects of the + type specified """ if len(obj_list) == 0: return [] diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py index b1202f2b1..05e49de83 100644 --- a/nova/virt/vmwareapi/vm_util.py +++ b/nova/virt/vmwareapi/vm_util.py @@ -24,9 +24,7 @@ from nova.virt.vmwareapi.VimService_services_types import ns0 def build_datastore_path(datastore_name, path): - """ - Build the datastore compliant path - """ + """Builds the datastore compliant path.""" return "[%s] %s" % (datastore_name, path) @@ -46,9 +44,7 @@ def split_datastore_path(datastore_path): def get_vm_create_spec(instance, data_store_name, network_name="vmnet0", os_type="otherGuest"): - """ - Builds the VM Create spec - """ + """Builds the VM Create spec.""" config_spec = ns0.VirtualMachineConfigSpec_Def( "VirtualMachineConfigSpec").pyclass() @@ -101,7 +97,8 @@ def create_controller_spec(key): def create_network_spec(network_name, mac_address): """ - Builds a config spec for the addition of a new network adapter to the VM + Builds a config spec for the addition of a new network adapter to + the VM. """ network_spec = \ ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() @@ -137,9 +134,7 @@ def create_network_spec(network_name, mac_address): def get_datastore_search_sepc(pattern=None): - """ - Builds the datastore search spec. - """ + """Builds the datastore search spec.""" host_datastore_browser_search_spec = \ ns0.HostDatastoreBrowserSearchSpec_Def( "HostDatastoreBrowserSearchSpec").pyclass() @@ -155,9 +150,7 @@ def get_datastore_search_sepc(pattern=None): def get_vmdk_attach_config_sepc(disksize, file_path, adapter_type="lsiLogic"): - """ - Builds the vmdk attach config spec. - """ + """Builds the vmdk attach config spec.""" config_spec = ns0.VirtualMachineConfigSpec_Def( "VirtualMachineConfigSpec").pyclass() @@ -182,9 +175,7 @@ def get_vmdk_attach_config_sepc(disksize, file_path, adapter_type="lsiLogic"): def get_vmdk_file_path_and_adapter_type(hardware_devices): - """ - Gets the vmdk file path and the storage adapter type - """ + """Gets the vmdk file path and the storage adapter type.""" if isinstance(hardware_devices.typecode, ns0.ArrayOfVirtualDevice_Def): hardware_devices = hardware_devices.VirtualDevice vmdk_file_path = None @@ -212,9 +203,7 @@ def get_vmdk_file_path_and_adapter_type(hardware_devices): def get_copy_virtual_disk_spec(adapter_type="lsilogic"): - """ - Builds the Virtual Disk copy spec. - """ + """Builds the Virtual Disk copy spec.""" dest_spec = ns0.VirtualDiskSpec_Def("VirtualDiskSpec").pyclass() dest_spec.AdapterType = adapter_type dest_spec.DiskType = "thick" @@ -222,9 +211,7 @@ def get_copy_virtual_disk_spec(adapter_type="lsilogic"): def get_vmdk_create_spec(size_in_kb, adapter_type="lsiLogic"): - """ - Builds the virtual disk create sepc. - """ + """Builds the virtual disk create sepc.""" create_vmdk_spec = \ ns0.FileBackedVirtualDiskSpec_Def("VirtualDiskSpec").pyclass() create_vmdk_spec._adapterType = adapter_type @@ -234,9 +221,7 @@ def get_vmdk_create_spec(size_in_kb, adapter_type="lsiLogic"): def create_virtual_disk_spec(disksize, controller_key, file_path=None): - """ - Creates a Spec for the addition/attaching of a Virtual Disk to the VM - """ + """Creates a Spec for the addition/attaching of a Virtual Disk to the VM""" virtual_device_config = \ ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() virtual_device_config._operation = "add" @@ -277,9 +262,7 @@ def create_virtual_disk_spec(disksize, controller_key, file_path=None): def get_dummy_vm_create_spec(name, data_store_name): - """ - Builds the dummy VM create spec - """ + """Builds the dummy VM create spec.""" config_spec = ns0.VirtualMachineConfigSpec_Def( "VirtualMachineConfigSpec").pyclass() @@ -313,9 +296,7 @@ def get_dummy_vm_create_spec(name, data_store_name): def get_machine_id_change_spec(mac, ip_addr, netmask, gateway): - """ - Builds the machine id change config spec - """ + """Builds the machine id change config spec.""" machine_id_str = "%s;%s;%s;%s" % (mac, ip_addr, netmask, gateway) virtual_machine_config_spec = ns0.VirtualMachineConfigSpec_Def( "VirtualMachineConfigSpec").pyclass() diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index 4eda4ef0e..da22588e3 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -40,20 +40,14 @@ VMWARE_POWER_STATES = { class VMWareVMOps(object): - """ - Management class for VM-related tasks - """ + """Management class for VM-related tasks""" def __init__(self, session): - """ - Initializer - """ + """Initializer""" self._session = session def _wait_with_callback(self, instance_id, task, callback): - """ - Waits for the task to finish and does a callback after - """ + """Waits for the task to finish and does a callback after""" ret = None try: ret = self._session._wait_for_task(instance_id, task) @@ -62,10 +56,8 @@ class VMWareVMOps(object): callback(ret) def list_instances(self): - """ - Lists the VM instances that are registered with the ESX host - """ - LOG.debug("Getting list of instances") + """Lists the VM instances that are registered with the ESX host""" + LOG.debug(_("Getting list of instances")) vms = self._session._call_method(vim_util, "get_objects", "VirtualMachine", ["name", "runtime.connectionState"]) @@ -81,7 +73,7 @@ class VMWareVMOps(object): # Ignoring the oprhaned or inaccessible VMs if conn_state not in ["orphaned", "inaccessible"]: lst_vm_names.append(vm_name) - LOG.debug("Got total of %s instances" % str(len(lst_vm_names))) + LOG.debug(_("Got total of %s instances") % str(len(lst_vm_names))) return lst_vm_names def spawn(self, instance): @@ -140,7 +132,7 @@ class VMWareVMOps(object): break if data_store_name is None: - msg = "Couldn't get a local Datastore reference" + msg = _("Couldn't get a local Datastore reference") LOG.exception(msg) raise Exception(msg) @@ -158,7 +150,7 @@ class VMWareVMOps(object): res_pool_mor = self._session._call_method(vim_util, "get_objects", "ResourcePool")[0].Obj - LOG.debug("Creating VM with the name %s on the ESX host" % + LOG.debug(_("Creating VM with the name %s on the ESX host") % \ instance.name) #Create the VM on the ESX host vm_create_task = self._session._call_method(self._session._get_vim(), @@ -166,7 +158,7 @@ class VMWareVMOps(object): config=config_spec, pool=res_pool_mor) self._session._wait_for_task(instance.id, vm_create_task) - LOG.debug("Created VM with the name %s on the ESX host" % + LOG.debug(_("Created VM with the name %s on the ESX host") % \ instance.name) # Set the machine id for the VM for setting the IP @@ -189,8 +181,8 @@ class VMWareVMOps(object): #depend on the size of the disk, thin/thick provisioning and the #storage adapter type. #Here we assume thick provisioning and lsiLogic for the adapter type - LOG.debug("Creating Virtual Disk of size %s KB and adapter type %s on " - "the ESX host local store %s " % + LOG.debug(_("Creating Virtual Disk of size %sKB and adapter type %s on" + " the ESX host local store %s ") % \ (vmdk_file_size_in_kb, adapter_type, data_store_name)) vmdk_create_spec = vm_util.get_vmdk_create_spec(vmdk_file_size_in_kb, adapter_type) @@ -201,21 +193,21 @@ class VMWareVMOps(object): datacenter=self._get_datacenter_name_and_ref()[0], spec=vmdk_create_spec) self._session._wait_for_task(instance.id, vmdk_create_task) - LOG.debug("Created Virtual Disk of size %s KB on the ESX host local" - "store %s " % (vmdk_file_size_in_kb, data_store_name)) + LOG.debug(_("Created Virtual Disk of size %s KB on the ESX host local" + "store %s ") % (vmdk_file_size_in_kb, data_store_name)) - LOG.debug("Deleting the file %s on the ESX host local" - "store %s " % (flat_uploaded_vmdk_path, data_store_name)) + LOG.debug(_("Deleting the file %s on the ESX host local" + "store %s ") % (flat_uploaded_vmdk_path, data_store_name)) #Delete the -flat.vmdk file created. .vmdk file is retained. vmdk_delete_task = self._session._call_method(self._session._get_vim(), "DeleteDatastoreFile_Task", self._session._get_vim().get_service_content().FileManager, name=flat_uploaded_vmdk_path) self._session._wait_for_task(instance.id, vmdk_delete_task) - LOG.debug("Deleted the file %s on the ESX host local" - "store %s " % (flat_uploaded_vmdk_path, data_store_name)) + LOG.debug(_("Deleted the file %s on the ESX host local" + "store %s ") % (flat_uploaded_vmdk_path, data_store_name)) - LOG.debug("Downloading image file data %s to the ESX data store %s " % + LOG.debug(_("Downloading image file %s to the ESX data store %s ") % \ (instance.image_id, data_store_name)) # Upload the -flat.vmdk file whose meta-data file we just created above vmware_images.fetch_image( @@ -226,7 +218,7 @@ class VMWareVMOps(object): datastore_name=data_store_name, cookies=self._session._get_vim().proxy.binding.cookies, file_path=flat_uploaded_vmdk_name) - LOG.debug("Downloaded image file data %s to the ESX data store %s " % + LOG.debug(_("Downloaded image file %s to the ESX data store %s ") % \ (instance.image_id, data_store_name)) #Attach the vmdk uploaded to the VM. VM reconfigure is done to do so. @@ -234,21 +226,21 @@ class VMWareVMOps(object): vmdk_file_size_in_kb, uploaded_vmdk_path, adapter_type) vm_ref = self._get_vm_ref_from_the_name(instance.name) - LOG.debug("Reconfiguring VM instance %s to attach the image " - "disk" % instance.name) + LOG.debug(_("Reconfiguring VM instance %s to attach the image " + "disk") % instance.name) reconfig_task = self._session._call_method(self._session._get_vim(), "ReconfigVM_Task", vm_ref, spec=vmdk_attach_config_spec) self._session._wait_for_task(instance.id, reconfig_task) - LOG.debug("Reconfigured VM instance %s to attach the image " - "disk" % instance.name) + LOG.debug(_("Reconfigured VM instance %s to attach the image " + "disk") % instance.name) - LOG.debug("Powering on the VM instance %s " % instance.name) + LOG.debug(_("Powering on the VM instance %s ") % instance.name) #Power On the VM power_on_task = self._session._call_method(self._session._get_vim(), "PowerOnVM_Task", vm_ref) self._session._wait_for_task(instance.id, power_on_task) - LOG.debug("Powered on the VM instance %s " % instance.name) + LOG.debug(_("Powered on the VM instance %s ") % instance.name) def snapshot(self, instance, snapshot_name): """ @@ -266,7 +258,7 @@ class VMWareVMOps(object): """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception("instance - %s not present" % instance.name) + raise Exception(_("instance - %s not present") % instance.name) #Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method(vim_util, @@ -279,7 +271,7 @@ class VMWareVMOps(object): "get_dynamic_property", vm_ref, "VirtualMachine", "summary.config.guestId") #Create a snapshot of the VM - LOG.debug("Creating Snapshot of the VM instance %s " % instance.name) + LOG.debug(_("Creating Snapshot of the VM instance %s") % instance.name) snapshot_task = self._session._call_method(self._session._get_vim(), "CreateSnapshot_Task", vm_ref, name="%s-snapshot" % instance.name, @@ -287,7 +279,7 @@ class VMWareVMOps(object): memory=True, quiesce=True) self._session._wait_for_task(instance.id, snapshot_task) - LOG.debug("Created Snapshot of the VM instance %s " % instance.name) + LOG.debug(_("Created Snapshot of the VM instance %s ") % instance.name) datastore_name = vm_util.split_datastore_path( vmdk_file_path_before_snapshot)[0] @@ -320,8 +312,8 @@ class VMWareVMOps(object): #Copy the contents of the disk ( or disks, if there were snapshots #done earlier) to a temporary vmdk file. - LOG.debug("Copying disk data before snapshot of the VM instance %s " % - instance.name) + LOG.debug(_("Copying disk data before snapshot of " + "the VM instance %s") % instance.name) copy_disk_task = self._session._call_method(self._session._get_vim(), "CopyVirtualDisk_Task", self._session._get_vim().get_service_content().VirtualDiskManager, @@ -332,11 +324,11 @@ class VMWareVMOps(object): destSpec=copy_spec, force=False) self._session._wait_for_task(instance.id, copy_disk_task) - LOG.debug("Copied disk data before snapshot of the VM instance %s " % - instance.name) + LOG.debug(_("Copied disk data before snapshot of " + "the VM instance %s") % instance.name) #Upload the contents of -flat.vmdk file which has the disk data. - LOG.debug("Uploading image %s" % snapshot_name) + LOG.debug(_("Uploading image %s") % snapshot_name) vmware_images.upload_image( snapshot_name, instance, @@ -348,25 +340,25 @@ class VMWareVMOps(object): datastore_name=datastore_name, cookies=self._session._get_vim().proxy.binding.cookies, file_path="vmware-tmp/%s-flat.vmdk" % random_name) - LOG.debug("Uploaded image %s" % snapshot_name) + LOG.debug(_("Uploaded image %s") % snapshot_name) #Delete the temporary vmdk created above. - LOG.debug("Deleting temporary vmdk file %s" % dest_vmdk_file_location) + LOG.debug(_("Deleting temporary vmdk file %s") % \ + dest_vmdk_file_location) remove_disk_task = self._session._call_method(self._session._get_vim(), "DeleteVirtualDisk_Task", self._session._get_vim().get_service_content().VirtualDiskManager, name=dest_vmdk_file_location, datacenter=dc_ref) self._session._wait_for_task(instance.id, remove_disk_task) - LOG.debug("Deleted temporary vmdk file %s" % dest_vmdk_file_location) + LOG.debug(_("Deleted temporary vmdk file %s") % \ + dest_vmdk_file_location) def reboot(self, instance): - """ - Reboot a VM instance - """ + """Reboot a VM instance""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception("instance - %s not present" % instance.name) + raise Exception(_("instance - %s not present") % instance.name) lst_properties = ["summary.guest.toolsStatus", "runtime.powerState"] props = self._session._call_method(vim_util, "get_object_properties", None, vm_ref, "VirtualMachine", @@ -382,22 +374,22 @@ class VMWareVMOps(object): #Raise an exception if the VM is not powered On. if pwr_state not in ["poweredOn"]: - raise Exception("instance - %s not poweredOn. So can't be " - "rebooted." % instance.name) + raise Exception(_("instance - %s not poweredOn. So can't be " + "rebooted.") % instance.name) #If vmware tools are installed in the VM, then do a guest reboot. #Otherwise do a hard reset. if tools_status not in ['toolsNotInstalled', 'toolsNotRunning']: - LOG.debug("Rebooting guest OS of VM %s" % instance.name) + LOG.debug(_("Rebooting guest OS of VM %s") % instance.name) self._session._call_method(self._session._get_vim(), "RebootGuest", vm_ref) - LOG.debug("Rebooted guest OS of VM %s" % instance.name) + LOG.debug(_("Rebooted guest OS of VM %s") % instance.name) else: - LOG.debug("Doing hard reboot of VM %s" % instance.name) + LOG.debug(_("Doing hard reboot of VM %s") % instance.name) reset_task = self._session._call_method(self._session._get_vim(), "ResetVM_Task", vm_ref) self._session._wait_for_task(instance.id, reset_task) - LOG.debug("Did hard reboot of VM %s" % instance.name) + LOG.debug(_("Did hard reboot of VM %s") % instance.name) def destroy(self, instance): """ @@ -409,7 +401,7 @@ class VMWareVMOps(object): try: vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - LOG.debug("instance - %s not present" % instance.name) + LOG.debug(_("instance - %s not present") % instance.name) return lst_properties = ["config.files.vmPathName", "runtime.powerState"] props = self._session._call_method(vim_util, @@ -428,61 +420,55 @@ class VMWareVMOps(object): vm_util.split_datastore_path(vm_config_pathname) #Power off the VM if it is in PoweredOn state. if pwr_state == "poweredOn": - LOG.debug("Powering off the VM %s" % instance.name) + LOG.debug(_("Powering off the VM %s") % instance.name) poweroff_task = self._session._call_method( self._session._get_vim(), "PowerOffVM_Task", vm_ref) self._session._wait_for_task(instance.id, poweroff_task) - LOG.debug("Powered off the VM %s" % instance.name) + LOG.debug(_("Powered off the VM %s") % instance.name) #Un-register the VM try: - LOG.debug("Unregistering the VM %s" % instance.name) + LOG.debug(_("Unregistering the VM %s") % instance.name) self._session._call_method(self._session._get_vim(), "UnregisterVM", vm_ref) - LOG.debug("Unregistered the VM %s" % instance.name) + LOG.debug(_("Unregistered the VM %s") % instance.name) except Exception, excep: - LOG.warn("In vmwareapi:vmops:destroy, got this exception while" - " un-registering the VM: " + str(excep)) + LOG.warn(_("In vmwareapi:vmops:destroy, got this exception " + "while un-registering the VM: ") + str(excep)) #Delete the folder holding the VM related content on the datastore. try: dir_ds_compliant_path = vm_util.build_datastore_path( datastore_name, os.path.dirname(vmx_file_path)) - LOG.debug("Deleting contents of the VM %s from datastore %s " % - (instance.name, datastore_name)) + LOG.debug(_("Deleting contents of the VM %s from " + "datastore %s") % (instance.name, datastore_name)) delete_task = self._session._call_method( self._session._get_vim(), "DeleteDatastoreFile_Task", self._session._get_vim().get_service_content().FileManager, name=dir_ds_compliant_path) self._session._wait_for_task(instance.id, delete_task) - LOG.debug("Deleted contents of the VM %s from datastore %s " % - (instance.name, datastore_name)) + LOG.debug(_("Deleted contents of the VM %s from " + "datastore %s") % (instance.name, datastore_name)) except Exception, excep: - LOG.warn("In vmwareapi:vmops:destroy, " + LOG.warn(_("In vmwareapi:vmops:destroy, " "got this exception while deleting" - " the VM contents from the disk: " + str(excep)) + " the VM contents from the disk: ") + str(excep)) except Exception, e: LOG.exception(e) def pause(self, instance, callback): - """ - Pause a VM instance - """ + """Pause a VM instance""" return "Not Implemented" def unpause(self, instance, callback): - """ - Un-Pause a VM instance - """ + """Un-Pause a VM instance""" return "Not Implemented" def suspend(self, instance, callback): - """ - Suspend the specified instance - """ + """Suspend the specified instance""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise Exception("instance - %s not present" % instance.name) @@ -492,47 +478,43 @@ class VMWareVMOps(object): "VirtualMachine", "runtime.powerState") #Only PoweredOn VMs can be suspended. if pwr_state == "poweredOn": - LOG.debug("Suspending the VM %s " % instance.name) + LOG.debug(_("Suspending the VM %s ") % instance.name) suspend_task = self._session._call_method(self._session._get_vim(), "SuspendVM_Task", vm_ref) self._wait_with_callback(instance.id, suspend_task, callback) - LOG.debug("Suspended the VM %s " % instance.name) + LOG.debug(_("Suspended the VM %s ") % instance.name) #Raise Exception if VM is poweredOff elif pwr_state == "poweredOff": - raise Exception("instance - %s is poweredOff and hence can't " - "be suspended." % instance.name) - LOG.debug("VM %s was already in suspended state. So returning without " - "doing anything" % instance.name) + raise Exception(_("instance - %s is poweredOff and hence can't " + "be suspended.") % instance.name) + LOG.debug(_("VM %s was already in suspended state. So returning " + "without doing anything") % instance.name) def resume(self, instance, callback): - """ - Resume the specified instance - """ + """Resume the specified instance""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception("instance - %s not present" % instance.name) + raise Exception(_("instance - %s not present") % instance.name) pwr_state = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "runtime.powerState") if pwr_state.lower() == "suspended": - LOG.debug("Resuming the VM %s " % instance.name) + LOG.debug(_("Resuming the VM %s ") % instance.name) suspend_task = self._session._call_method( self._session._get_vim(), "PowerOnVM_Task", vm_ref) self._wait_with_callback(instance.id, suspend_task, callback) - LOG.debug("Resumed the VM %s " % instance.name) + LOG.debug(_("Resumed the VM %s ") % instance.name) else: - raise Exception("instance - %s not in Suspended state and hence " - "can't be Resumed." % instance.name) + raise Exception(_("instance - %s not in Suspended state and hence " + "can't be Resumed.") % instance.name) def get_info(self, instance_name): - """ - Return data about the VM instance - """ + """Return data about the VM instance""" vm_ref = self._get_vm_ref_from_the_name(instance_name) if vm_ref is None: - raise Exception("instance - %s not present" % instance_name) + raise Exception(_("instance - %s not present") % instance_name) lst_properties = ["summary.config.numCpu", "summary.config.memorySizeMB", @@ -560,31 +542,25 @@ class VMWareVMOps(object): 'cpu_time': 0} def get_diagnostics(self, instance): - """ - Return data about VM diagnostics - """ + """Return data about VM diagnostics""" return "Not Implemented" def get_console_output(self, instance): - """ - Return snapshot of console - """ + """Return snapshot of console""" return 'FAKE CONSOLE OUTPUT of instance' def get_ajax_console(self, instance): - """ - Return link to instance's ajax console - """ + """Return link to instance's ajax console""" return 'http://fakeajaxconsole/fake_url' def _set_machine_id(self, instance): """ - Set the machine id of the VM for guest tools to pick up and change the - IP + Set the machine id of the VM for guest tools to pick up + and change the IP """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception("instance - %s not present" % instance.name) + raise Exception(_("instance - %s not present") % instance.name) network = db.network_get_by_instance(context.get_admin_context(), instance['id']) mac_addr = instance.mac_address @@ -594,23 +570,21 @@ class VMWareVMOps(object): instance['id']) machine_id_chanfge_spec = vm_util.get_machine_id_change_spec(mac_addr, ip_addr, net_mask, gateway) - LOG.debug("Reconfiguring VM instance %s to set the machine id " - "with ip - %s" % (instance.name, ip_addr)) + LOG.debug(_("Reconfiguring VM instance %s to set the machine id " + "with ip - %s") % (instance.name, ip_addr)) reconfig_task = self._session._call_method(self._session._get_vim(), "ReconfigVM_Task", vm_ref, spec=machine_id_chanfge_spec) self._session._wait_for_task(instance.id, reconfig_task) - LOG.debug("Reconfigured VM instance %s to set the machine id " - "with ip - %s" % (instance.name, ip_addr)) + LOG.debug(_("Reconfigured VM instance %s to set the machine id " + "with ip - %s") % (instance.name, ip_addr)) def _create_dummy_vm_for_test(self, instance): - """ - Create a dummy VM for testing purpose - """ + """Create a dummy VM for testing purpose""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref: - raise Exception('Attempted to create a VM with a name %s, ' - 'but that already exists on the host' % instance.name) + raise Exception(_('Attempted to create a VM with a name %s, ' + 'but that already exists on the host') % instance.name) data_stores = self._session._call_method(vim_util, "get_objects", "Datastore", ["summary.type", "summary.name"]) @@ -629,7 +603,7 @@ class VMWareVMOps(object): break if data_store_name is None: - msg = "Couldn't get a local Datastore reference" + msg = _("Couldn't get a local Datastore reference") LOG.exception(msg) raise Exception(msg) @@ -659,9 +633,7 @@ class VMWareVMOps(object): self._session._wait_for_task(instance.id, power_on_task) def _get_network_with_the_name(self, network_name="vmnet0"): - ''' - Gets reference to the network whose name is passed as the argument. - ''' + """Gets reference to network whose name is passed as the argument.""" datacenters = self._session._call_method(vim_util, "get_objects", "Datacenter", ["network"]) vm_networks = datacenters[0].PropSet[0].Val.ManagedObjectReference @@ -674,17 +646,13 @@ class VMWareVMOps(object): return None def _get_datacenter_name_and_ref(self): - """ - Get the datacenter name and the reference. - """ + """Get the datacenter name and the reference.""" dc_obj = self._session._call_method(vim_util, "get_objects", "Datacenter", ["name"]) return dc_obj[0].Obj, dc_obj[0].PropSet[0].Val def _path_exists(self, ds_browser, ds_path): - """ - Check if the path exists on the datastore - """ + """Check if the path exists on the datastore.""" search_task = self._session._call_method(self._session._get_vim(), "SearchDatastore_Task", ds_browser, @@ -709,16 +677,14 @@ class VMWareVMOps(object): directory with this name is formed at the topmost level of the DataStore. """ - LOG.debug("Creating directory with path %s" % ds_path) + LOG.debug(_("Creating directory with path %s") % ds_path) self._session._call_method(self._session._get_vim(), "MakeDirectory", self._session._get_vim().get_service_content().FileManager, name=ds_path, createParentDirectories=False) - LOG.debug("Created directory with path %s" % ds_path) + LOG.debug(_("Created directory with path %s") % ds_path) def _get_vm_ref_from_the_name(self, vm_name): - """ - Get reference to the VM with the name specified. - """ + """Get reference to the VM with the name specified.""" vms = self._session._call_method(vim_util, "get_objects", "VirtualMachine", ["name"]) for vm in vms: diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py index d3b1dc446..78bbb7fec 100644 --- a/nova/virt/vmwareapi/vmware_images.py +++ b/nova/virt/vmwareapi/vmware_images.py @@ -39,9 +39,7 @@ TEST_IMAGE_PATH = "/tmp/vmware-test-images" def start_transfer(read_file_handle, write_file_handle, data_size): - """ - Start the data transfer from the read handle to the write handle. - """ + """Start the data transfer from the read handle to the write handle.""" #The thread safe pipe thread_safe_pipe = io_util.ThreadSafePipe(QUEUE_BUFFER_SIZE) #The read thread @@ -52,7 +50,7 @@ def start_transfer(read_file_handle, write_file_handle, data_size): WRITE_CHUNKSIZE, long(data_size)) read_thread.start() write_thread.start() - LOG.debug("Starting image file transfer") + LOG.debug(_("Starting image file transfer")) #Wait till both the read thread and the write thread are done while not (read_thread.is_done() and write_thread.is_done()): if read_thread.get_error() or write_thread.get_error(): @@ -68,16 +66,14 @@ def start_transfer(read_file_handle, write_file_handle, data_size): LOG.exception(str(write_excep)) raise Exception(write_excep) time.sleep(2) - LOG.debug("Finished image file transfer and closing the file handles") + LOG.debug(_("Finished image file transfer and closing the file handles")) #Close the file handles read_file_handle.close() write_file_handle.close() def fetch_image(image, instance, **kwargs): - """ - Fetch an image for attaching to the newly created VM - """ + """Fetch an image for attaching to the newly created VM.""" #Depending upon the image service, make appropriate image service call if FLAGS.image_service == "nova.image.glance.GlanceImageService": func = _get_glance_image @@ -88,15 +84,13 @@ def fetch_image(image, instance, **kwargs): elif FLAGS.image_service == "nova.FakeImageService": func = _get_fake_image else: - raise NotImplementedError("The Image Service %s is not implemented" + raise NotImplementedError(_("The Image Service %s is not implemented") % FLAGS.image_service) return func(image, instance, **kwargs) def upload_image(image, instance, **kwargs): - """ - Upload the newly snapshotted VM disk file. - """ + """Upload the newly snapshotted VM disk file.""" #Depending upon the image service, make appropriate image service call if FLAGS.image_service == "nova.image.glance.GlanceImageService": func = _put_glance_image @@ -107,16 +101,14 @@ def upload_image(image, instance, **kwargs): elif FLAGS.image_service == "nova.FakeImageService": func = _put_fake_image else: - raise NotImplementedError("The Image Service %s is not implemented" + raise NotImplementedError(_("The Image Service %s is not implemented") % FLAGS.image_service) return func(image, instance, **kwargs) def _get_glance_image(image, instance, **kwargs): - """ - Download image from the glance image server. - """ - LOG.debug("Downloading image %s from glance image server" % image) + """Download image from the glance image server.""" + LOG.debug(_("Downloading image %s from glance image server") % image) read_file_handle = read_write_util.GlanceHTTPReadFile(FLAGS.glance_host, FLAGS.glance_port, image) @@ -129,29 +121,24 @@ def _get_glance_image(image, instance, **kwargs): kwargs.get("file_path"), file_size) start_transfer(read_file_handle, write_file_handle, file_size) - LOG.debug("Downloaded image %s from glance image server" % image) + LOG.debug(_("Downloaded image %s from glance image server") % image) def _get_s3_image(image, instance, **kwargs): - """ - Download image from the S3 image server. - """ + """Download image from the S3 image server.""" raise NotImplementedError def _get_local_image(image, instance, **kwargs): - """ - Download image from the local nova compute node. - """ + """Download image from the local nova compute node.""" raise NotImplementedError def _get_fake_image(image, instance, **kwargs): + """ Download a fake image from the nova local file repository for testing + purposes. """ - Download a fake image from the nova local file repository for testing - purposes - """ - LOG.debug("Downloading image %s from fake image service" % image) + LOG.debug(_("Downloading image %s from fake image service") % image) image = str(image) file_path = os.path.join(TEST_IMAGE_PATH, image, image) file_path = os.path.abspath(file_path) @@ -165,14 +152,12 @@ def _get_fake_image(image, instance, **kwargs): kwargs.get("file_path"), file_size) start_transfer(read_file_handle, write_file_handle, file_size) - LOG.debug("Downloaded image %s from fake image service" % image) + LOG.debug(_("Downloaded image %s from fake image service") % image) def _put_glance_image(image, instance, **kwargs): - """ - Upload the snapshotted vm disk file to Glance image server - """ - LOG.debug("Uploading image %s to the Glance image server" % image) + """Upload the snapshotted vm disk file to Glance image server.""" + LOG.debug(_("Uploading image %s to the Glance image server") % image) read_file_handle = read_write_util.VmWareHTTPReadFile( kwargs.get("host"), kwargs.get("data_center_name"), @@ -189,29 +174,24 @@ def _put_glance_image(image, instance, **kwargs): kwargs.get("adapter_type"), kwargs.get("image_version")) start_transfer(read_file_handle, write_file_handle, file_size) - LOG.debug("Uploaded image %s to the Glance image server" % image) + LOG.debug(_("Uploaded image %s to the Glance image server") % image) def _put_local_image(image, instance, **kwargs): - """ - Upload the snapshotted vm disk file to the local nova compute node. - """ + """Upload the snapshotted vm disk file to the local nova compute node.""" raise NotImplementedError def _put_s3_image(image, instance, **kwargs): - """ - Upload the snapshotted vm disk file to S3 image server. - """ + """Upload the snapshotted vm disk file to S3 image server.""" raise NotImplementedError def _put_fake_image(image, instance, **kwargs): + """ Upload a dummy vmdk from the ESX host to the local file repository of + the nova node for testing purposes. """ - Upload a dummy vmdk from the ESX host to the local file repository of - the nova node for testing purposes - """ - LOG.debug("Uploading image %s to the Fake Image Service" % image) + LOG.debug(_("Uploading image %s to the Fake Image Service") % image) read_file_handle = read_write_util.VmWareHTTPReadFile( kwargs.get("host"), kwargs.get("data_center_name"), @@ -231,7 +211,7 @@ def _put_fake_image(image, instance, **kwargs): file_path = os.path.abspath(file_path) write_file_handle = read_write_util.FakeFileWrite(file_path) start_transfer(read_file_handle, write_file_handle, file_size) - LOG.debug("Uploaded image %s to the Fake Image Service" % image) + LOG.debug(_("Uploaded image %s to the Fake Image Service") % image) def get_vmdk_size_and_properties(image, instance): @@ -240,7 +220,7 @@ def get_vmdk_size_and_properties(image, instance): Need this to create the dummy virtual disk for the meta-data file. The geometry of the disk created depends on the size. """ - LOG.debug("Getting image size for the image %s" % image) + LOG.debug(_("Getting image size for the image %s") % image) if FLAGS.image_service == "nova.image.glance.GlanceImageService": read_file_handle = read_write_util.GlanceHTTPReadFile( FLAGS.glance_host, @@ -258,5 +238,5 @@ def get_vmdk_size_and_properties(image, instance): size = read_file_handle.get_size() properties = read_file_handle.get_image_properties() read_file_handle.close() - LOG.debug("Got image size of %s for the image %s" % (size, image)) + LOG.debug(_("Got image size of %s for the image %s") % (size, image)) return size, properties diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index 421efe91c..739cb53c7 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -76,11 +76,10 @@ TIME_BETWEEN_API_CALL_RETRIES = 2.0 class TaskState: - """ - Enumeration class for different states of task - 0 - Task completed successfully - 1 - Task is in queued state - 2 - Task is in running state + """Enumeration class for different states of task + 0 - Task completed successfully + 1 - Task is in queued state + 2 - Task is in running state """ TASK_SUCCESS = 0 @@ -89,27 +88,19 @@ class TaskState: class Failure(Exception): - """ - Base Exception class for handling task failures - """ + """Base Exception class for handling task failures""" def __init__(self, details): - """ - Initializer - """ + """Initializer""" self.details = details def __str__(self): - """ - The informal string representation of the object - """ + """The informal string representation of the object""" return str(self.details) def get_connection(_): - """ - Sets up the ESX host connection - """ + """Sets up the ESX host connection""" host_ip = FLAGS.vmwareapi_host_ip host_username = FLAGS.vmwareapi_host_username host_password = FLAGS.vmwareapi_host_password @@ -124,143 +115,98 @@ def get_connection(_): class VMWareESXConnection(object): - """ - The ESX host connection object - """ + """The ESX host connection object""" def __init__(self, host_ip, host_username, host_password, api_retry_count, scheme="https"): - """ - The Initializer - """ + """The Initializer""" session = VMWareAPISession(host_ip, host_username, host_password, api_retry_count, scheme=scheme) self._vmops = VMWareVMOps(session) def init_host(self, host): - """ - Do the initialization that needs to be done - """ + """Do the initialization that needs to be done""" #FIXME(sateesh): implement this pass def list_instances(self): - """ - List VM instances - """ + """List VM instances""" return self._vmops.list_instances() def spawn(self, instance): - """ - Create VM instance - """ + """Create VM instance""" self._vmops.spawn(instance) def snapshot(self, instance, name): - """ - Create snapshot from a running VM instance - """ + """Create snapshot from a running VM instance""" self._vmops.snapshot(instance, name) def reboot(self, instance): - """ - Reboot VM instance - """ + """Reboot VM instance""" self._vmops.reboot(instance) def destroy(self, instance): - """ - Destroy VM instance - """ + """Destroy VM instance""" self._vmops.destroy(instance) def pause(self, instance, callback): - """ - Pause VM instance - """ + """Pause VM instance""" self._vmops.pause(instance, callback) def unpause(self, instance, callback): - """ - Unpause paused VM instance - """ + """Unpause paused VM instance""" self._vmops.unpause(instance, callback) def suspend(self, instance, callback): - """ - Suspend the specified instance - """ + """Suspend the specified instance""" self._vmops.suspend(instance, callback) def resume(self, instance, callback): - """ - Resume the suspended VM instance - """ + """Resume the suspended VM instance""" self._vmops.resume(instance, callback) def get_info(self, instance_id): - """ - Return info about the VM instance - """ + """Return info about the VM instance""" return self._vmops.get_info(instance_id) def get_diagnostics(self, instance): - """ - Return data about VM diagnostics - """ + """Return data about VM diagnostics""" return self._vmops.get_info(instance) def get_console_output(self, instance): - """ - Return snapshot of console - """ + """Return snapshot of console""" return self._vmops.get_console_output(instance) def get_ajax_console(self, instance): - """ - Return link to instance's ajax console - """ + """Return link to instance's ajax console""" return self._vmops.get_ajax_console(instance) def attach_volume(self, instance_name, device_path, mountpoint): - """ - Attach volume storage to VM instance - """ + """Attach volume storage to VM instance""" pass def detach_volume(self, instance_name, mountpoint): - """ - Detach volume storage to VM instance - """ + """Detach volume storage to VM instance""" pass def get_console_pool_info(self, console_type): - """ - Get info about the host on which the VM resides - """ + """Get info about the host on which the VM resides""" esx_url = urlparse.urlparse(FLAGS.vmwareapi_host_ip) return {'address': esx_url.netloc, 'username': FLAGS.vmwareapi_host_password, 'password': FLAGS.vmwareapi_host_password} def _create_dummy_vm_for_test(self, instance): - """ - Creates a dummy 1MB VM with default parameters for testing purpose - """ + """Creates a dummy VM with default parameters for testing purpose""" return self._vmops._create_dummy_vm_for_test(instance) class VMWareAPISession(object): - """ - Sets up a session with the ESX host and handles all the calls made to the - host - """ + """Sets up a session with ESX host and handles all calls made to host""" def __init__(self, host_ip, host_username, host_password, api_retry_count, scheme="https"): - """ - Set the connection credentials - """ + """Set the connection credentials""" self._host_ip = host_ip self._host_username = host_username self._host_password = host_password @@ -271,9 +217,7 @@ class VMWareAPISession(object): self._create_session() def _create_session(self): - """ - Creates a session with the ESX host - """ + """Creates a session with the ESX host""" while True: try: # Login and setup the session with the ESX host for making @@ -296,14 +240,12 @@ class VMWareAPISession(object): self._session_id = session.Key return except Exception, excep: - LOG.critical("In vmwareapi:_create_session, " - "got this exception: %s" % excep) + LOG.info(_("In vmwareapi:_create_session, " + "got this exception: %s") % excep) raise Exception(excep) def __del__(self): - """ - The Destructor. Logs-out the session. - """ + """The Destructor. Logs-out the session.""" # Logout to avoid un-necessary increase in session count at the # ESX host try: @@ -312,9 +254,7 @@ class VMWareAPISession(object): pass def _call_method(self, module, method, *args, **kwargs): - """ - Calls a method within the module specified with args provided - """ + """Calls a method within the module specified with args provided""" args = list(args) retry_count = 0 exc = None @@ -355,14 +295,12 @@ class VMWareAPISession(object): break time.sleep(TIME_BETWEEN_API_CALL_RETRIES) - LOG.critical("In vmwareapi:_call_method, " - "got this exception: " % exc) + LOG.info(_("In vmwareapi:_call_method, " + "got this exception: ") % exc) raise Exception(exc) def _get_vim(self): - """ - Gets the VIM object reference - """ + """Gets the VIM object reference""" if self.vim is None: self._create_session() return self.vim @@ -397,19 +335,19 @@ class VMWareAPISession(object): TaskState.TASK_RUNNING]: return elif task_info.State == TaskState.TASK_SUCCESS: - LOG.info("Task [%s] %s status: success " % ( + LOG.info(_("Task [%s] %s status: success ") % ( task_name, str(task_ref))) done.send(TaskState.TASK_SUCCESS) else: error_info = str(task_info.Error.LocalizedMessage) action["error"] = error_info - LOG.warn("Task [%s] %s status: error [%s]" % ( + LOG.info(_("Task [%s] %s status: error [%s]") % ( task_name, str(task_ref), error_info)) done.send_exception(Exception(error_info)) db.instance_action_create(context.get_admin_context(), action) except Exception, excep: - LOG.warn("In vmwareapi:_poll_task, Got this error %s" % excep) + LOG.info(_("In vmwareapi:_poll_task, Got this error %s") % excep) done.send_exception(excep) -- cgit From 94bd7e2c45ca971e318813bb1e897fb5e79ab7bd Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 23 Feb 2011 12:05:46 -0600 Subject: Removed pass --- nova/virt/xenapi/vmops.py | 1 - 1 file changed, 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index bd57dc9a1..7bffd8c6c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -501,7 +501,6 @@ class VMOps(object): # Plug the VBD into the target instance self._session.call_xenapi("Async.VBD.plug", vbd_ref) - pass def unrescue(self, instance, callback): """Unrescue the specified instance""" -- cgit From 4a002ffdc1937856de7dbf35b83ae0dd78dfe4c6 Mon Sep 17 00:00:00 2001 From: sateesh Date: Thu, 24 Feb 2011 11:55:25 +0530 Subject: Fixed problems found in localized string formatting. Verified the fixes by running ./run_tests.sh -V. --- nova/virt/vmwareapi/io_util.py | 6 ++-- nova/virt/vmwareapi/vmops.py | 67 +++++++++++++++++++++++------------- nova/virt/vmwareapi/vmware_images.py | 4 ++- nova/virt/vmwareapi_conn.py | 15 ++++---- 4 files changed, 59 insertions(+), 33 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py index 6761d894c..b9645e220 100644 --- a/nova/virt/vmwareapi/io_util.py +++ b/nova/virt/vmwareapi/io_util.py @@ -131,8 +131,10 @@ class IOThread(Thread): if not self.transfer_size is None: if self.read_size < self.transfer_size: - raise IOError(_("Not enough data (%d of %d bytes)") % \ - (self.read_size, self.transfer_size)) + raise IOError(_("Not enough data (%(read_size)d of " + "%(transfer_size)d bytes)") % + {'read_size': self.read_size, + 'transfer_size': self.transfer_size}) except Exception: self._error = True diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index da22588e3..3e32fceef 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -181,9 +181,12 @@ class VMWareVMOps(object): #depend on the size of the disk, thin/thick provisioning and the #storage adapter type. #Here we assume thick provisioning and lsiLogic for the adapter type - LOG.debug(_("Creating Virtual Disk of size %sKB and adapter type %s on" - " the ESX host local store %s ") % \ - (vmdk_file_size_in_kb, adapter_type, data_store_name)) + LOG.debug(_("Creating Virtual Disk of size %(vmdk_file_size_in_kb)sKB" + " and adapter type %(adapter_type)s on" + " the ESX host local store %(data_store_name)s") % + {'vmdk_file_size_in_kb': vmdk_file_size_in_kb, + 'adapter_type': adapter_type, + 'data_store_name': data_store_name}) vmdk_create_spec = vm_util.get_vmdk_create_spec(vmdk_file_size_in_kb, adapter_type) vmdk_create_task = self._session._call_method(self._session._get_vim(), @@ -193,22 +196,30 @@ class VMWareVMOps(object): datacenter=self._get_datacenter_name_and_ref()[0], spec=vmdk_create_spec) self._session._wait_for_task(instance.id, vmdk_create_task) - LOG.debug(_("Created Virtual Disk of size %s KB on the ESX host local" - "store %s ") % (vmdk_file_size_in_kb, data_store_name)) - - LOG.debug(_("Deleting the file %s on the ESX host local" - "store %s ") % (flat_uploaded_vmdk_path, data_store_name)) + LOG.debug(_("Created Virtual Disk of size %(vmdk_file_size_in_kb)s KB" + " on the ESX host local store %(data_store_name)s ") % + {'vmdk_file_size_in_kb': vmdk_file_size_in_kb, + 'data_store_name': data_store_name}) + + LOG.debug(_("Deleting the file %(flat_uploaded_vmdk_path)s on " + "the ESX host local store %(data_store_names)s") % + {'flat_uploaded_vmdk_path': flat_uploaded_vmdk_path, + 'data_store_name': data_store_name}) #Delete the -flat.vmdk file created. .vmdk file is retained. vmdk_delete_task = self._session._call_method(self._session._get_vim(), "DeleteDatastoreFile_Task", self._session._get_vim().get_service_content().FileManager, name=flat_uploaded_vmdk_path) self._session._wait_for_task(instance.id, vmdk_delete_task) - LOG.debug(_("Deleted the file %s on the ESX host local" - "store %s ") % (flat_uploaded_vmdk_path, data_store_name)) - - LOG.debug(_("Downloading image file %s to the ESX data store %s ") % \ - (instance.image_id, data_store_name)) + LOG.debug(_("Deleted the file %(flat_uploaded_vmdk_path)s on " + "the ESX host local store %(data_store_name)s ") % + {'flat_uploaded_vmdk_path': flat_uploaded_vmdk_path, + 'data_store_name': data_store_name}) + + LOG.debug(_("Downloading image file %(image_id)s to the " + "ESX data store %(datastore_name)s ") % + {'image_id': instance.image_id, + 'data_store_name': data_store_name}) # Upload the -flat.vmdk file whose meta-data file we just created above vmware_images.fetch_image( instance.image_id, @@ -218,8 +229,10 @@ class VMWareVMOps(object): datastore_name=data_store_name, cookies=self._session._get_vim().proxy.binding.cookies, file_path=flat_uploaded_vmdk_name) - LOG.debug(_("Downloaded image file %s to the ESX data store %s ") % \ - (instance.image_id, data_store_name)) + LOG.debug(_("Downloaded image file %(image_id)s to the ESX data " + "store %(data_store_name)s ") % + {'image_id': instance.image_id, + 'data_store_name': data_store_name}) #Attach the vmdk uploaded to the VM. VM reconfigure is done to do so. vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_sepc( @@ -442,16 +455,20 @@ class VMWareVMOps(object): dir_ds_compliant_path = vm_util.build_datastore_path( datastore_name, os.path.dirname(vmx_file_path)) - LOG.debug(_("Deleting contents of the VM %s from " - "datastore %s") % (instance.name, datastore_name)) + LOG.debug(_("Deleting contents of the VM %(instance.name)s " + "from datastore %(datastore_name)s") % + {('instance.name': instance.name, + 'datastore_name': datastore_name)}) delete_task = self._session._call_method( self._session._get_vim(), "DeleteDatastoreFile_Task", self._session._get_vim().get_service_content().FileManager, name=dir_ds_compliant_path) self._session._wait_for_task(instance.id, delete_task) - LOG.debug(_("Deleted contents of the VM %s from " - "datastore %s") % (instance.name, datastore_name)) + LOG.debug(_("Deleted contents of the VM %(instance_name)s " + "from datastore %(datastore_name)s") % + {'instance_name': instance.name, + 'datastore_name': datastore_name}) except Exception, excep: LOG.warn(_("In vmwareapi:vmops:destroy, " "got this exception while deleting" @@ -570,14 +587,18 @@ class VMWareVMOps(object): instance['id']) machine_id_chanfge_spec = vm_util.get_machine_id_change_spec(mac_addr, ip_addr, net_mask, gateway) - LOG.debug(_("Reconfiguring VM instance %s to set the machine id " - "with ip - %s") % (instance.name, ip_addr)) + LOG.debug(_("Reconfiguring VM instance %(instance_name)s to set " + "the machine id with ip - %(ip_addr)s") % + {'instance_name': instance.name, + 'ip_addr': ip_addr}) reconfig_task = self._session._call_method(self._session._get_vim(), "ReconfigVM_Task", vm_ref, spec=machine_id_chanfge_spec) self._session._wait_for_task(instance.id, reconfig_task) - LOG.debug(_("Reconfigured VM instance %s to set the machine id " - "with ip - %s") % (instance.name, ip_addr)) + LOG.debug(_("Reconfigured VM instance %(instance_name)s to set " + "the machine id with ip - %(ip_addr)s") % + {'instance_name': instance.name, + 'ip_addr': ip_addr}) def _create_dummy_vm_for_test(self, instance): """Create a dummy VM for testing purpose""" diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py index 78bbb7fec..4aad657e6 100644 --- a/nova/virt/vmwareapi/vmware_images.py +++ b/nova/virt/vmwareapi/vmware_images.py @@ -238,5 +238,7 @@ def get_vmdk_size_and_properties(image, instance): size = read_file_handle.get_size() properties = read_file_handle.get_image_properties() read_file_handle.close() - LOG.debug(_("Got image size of %s for the image %s") % (size, image)) + LOG.debug(_("Got image size of %(size)s for the image %(image)s") % + {'size': size, + 'image': image}) return size, properties diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index 739cb53c7..29748fe81 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -335,17 +335,18 @@ class VMWareAPISession(object): TaskState.TASK_RUNNING]: return elif task_info.State == TaskState.TASK_SUCCESS: - LOG.info(_("Task [%s] %s status: success ") % ( - task_name, - str(task_ref))) + LOG.info(_("Task [%(taskname)s] %(taskref)s status: success") % + {'taskname': task_name, + 'taskref': str(task_ref)}) done.send(TaskState.TASK_SUCCESS) else: error_info = str(task_info.Error.LocalizedMessage) action["error"] = error_info - LOG.info(_("Task [%s] %s status: error [%s]") % ( - task_name, - str(task_ref), - error_info)) + LOG.info(_("Task [%(task_name)s] %(task_ref)s status: " + "error [%(error_info)s]") % + {'task_name': task_name, + 'task_ref': str(task_ref), + 'error_info': error_info}) done.send_exception(Exception(error_info)) db.instance_action_create(context.get_admin_context(), action) except Exception, excep: -- cgit From 8e2ebb1a963f58514d8fb6aab4a75627e72484b9 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Thu, 24 Feb 2011 16:04:13 +0000 Subject: stubbing out _is_vdi_pv for test purposes --- nova/virt/xenapi/vm_utils.py | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 80cc3035d..564a25057 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -400,19 +400,7 @@ class VMHelper(HelperBase): @classmethod def _lookup_image_glance(cls, session, vdi_ref): LOG.debug(_("Looking up vdi %s for PV kernel"), vdi_ref) - - def is_vdi_pv(dev): - LOG.debug(_("Running pygrub against %s"), dev) - output = os.popen('pygrub -qn /dev/%s' % dev) - for line in output.readlines(): - #try to find kernel string - m = re.search('(?<=kernel:)/.*(?:>)', line) - if m and m.group(0).find('xen') != -1: - LOG.debug(_("Found Xen kernel %s") % m.group(0)) - return True - LOG.debug(_("No Xen kernel found. Booting HVM.")) - return False - return with_vdi_attached_here(session, vdi_ref, True, is_vdi_pv) + return with_vdi_attached_here(session, vdi_ref, True, _is_vdi_pv) @classmethod def lookup(cls, session, i): @@ -714,6 +702,19 @@ def get_this_vm_ref(session): return session.get_xenapi().VM.get_by_uuid(get_this_vm_uuid()) +def _is_vdi_pv(dev): + LOG.debug(_("Running pygrub against %s"), dev) + output = os.popen('pygrub -qn /dev/%s' % dev) + for line in output.readlines(): + #try to find kernel string + m = re.search('(?<=kernel:)/.*(?:>)', line) + if m and m.group(0).find('xen') != -1: + LOG.debug(_("Found Xen kernel %s") % m.group(0)) + return True + LOG.debug(_("No Xen kernel found. Booting HVM.")) + return False + + def _stream_disk(dev, type, virtual_size, image_file): offset = 0 if type == ImageType.DISK: -- cgit From 9e018bbee1d4a308fdf1700bd25aa733cedc26e6 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 24 Feb 2011 13:01:16 -0600 Subject: Updated email in Authors --- nova/virt/xenapi/vmops.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 7bffd8c6c..a47d23f88 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -476,19 +476,15 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" vm = self._get_vm_opaque_ref(instance) - self._shutdown(instance, vm) + + # Temporary instance target_vm = VMHelper.lookup(self._session, "instance-00000001") - #target_vm = self.compute_api.create( - # context=context.get_admin_context(), - # instance_type="m1.tiny", - # image_id=1, - # kernel_id=3, - # ramdisk_id=2, - # display_name="test", - # display_description="test") - #print context.get_admin_context().__dict__ - #print target_vm + + # Plan of action + # Create `instance` object for rescue_vm + # rescue_instance = self._make_rescue_instance() # Write this + #rescue_vm = self.spawn(instance) vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] @@ -505,6 +501,8 @@ class VMOps(object): def unrescue(self, instance, callback): """Unrescue the specified instance""" vm = self._get_vm_opaque_ref(instance) + + # Temporary instance target_vm = VMHelper.lookup(self._session, "instance-00000001") vbds = self._session.get_xenapi().VM.get_VBDs(target_vm) -- cgit From 907df1b90e5c22eb82ce85bc12f48d8abf09b665 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 24 Feb 2011 13:57:11 -0600 Subject: nothing --- nova/virt/xenapi/vmops.py | 40 ++++++++++++++++------------------------ 1 file changed, 16 insertions(+), 24 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a47d23f88..0b9b7d0a4 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -475,37 +475,29 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" - vm = self._get_vm_opaque_ref(instance) - self._shutdown(instance, vm) - - # Temporary instance - target_vm = VMHelper.lookup(self._session, "instance-00000001") + #vm = self._get_vm_opaque_ref(instance) + #self._shutdown(instance, vm) - # Plan of action - # Create `instance` object for rescue_vm - # rescue_instance = self._make_rescue_instance() # Write this + print instance.__dict__ + print instance.name + print "%s-rescue" % instance.name #rescue_vm = self.spawn(instance) - vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] - vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] - vbd_ref = VMHelper.create_vbd( - self._session, - target_vm, - vdi_ref, - 1, - False) + #vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] + #vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] + #vbd_ref = VMHelper.create_vbd( + # self._session, + # rescue_vm, + # vdi_ref, + # 1, + # False) - # Plug the VBD into the target instance - self._session.call_xenapi("Async.VBD.plug", vbd_ref) + #self._session.call_xenapi("Async.VBD.plug", vbd_ref) def unrescue(self, instance, callback): """Unrescue the specified instance""" vm = self._get_vm_opaque_ref(instance) - - # Temporary instance - target_vm = VMHelper.lookup(self._session, "instance-00000001") - - vbds = self._session.get_xenapi().VM.get_VBDs(target_vm) + vbds = self._session.get_xenapi().VM.get_VBDs(vm) for vbd_ref in vbds: vbd = self._session.get_xenapi().VBD.get_record(vbd_ref) @@ -513,7 +505,7 @@ class VMOps(object): VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) - self._start(instance, vm) + self.reboot(instance) def get_info(self, instance): """Return data about VM instance""" -- cgit From 8635f7a306e4cfa41ad09a18602efa7793f6da95 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 24 Feb 2011 15:04:07 -0600 Subject: moved network injection and vif creation to above vm start in vmops spawn --- nova/virt/xenapi/vmops.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 76b88a8bd..3aa5a23e5 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -104,6 +104,10 @@ class VMOps(object): instance, kernel, ramdisk, pv_kernel) VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) + # inject_network_info and create vifs + networks = self.inject_network_info(instance) + self.create_vifs(instance, networks) + LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) instance_name = instance.name @@ -134,9 +138,7 @@ class VMOps(object): timer.f = _wait_for_boot - # call to reset network to inject network info and configure - networks = self.inject_network_info(instance) - self.create_vifs(instance, networks) + # call to reset network to configure network from xenstore self.reset_network(instance) return timer.start(interval=0.5, now=True) -- cgit From f4221346418ef103635b104fc152a2507d60a8dc Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 24 Feb 2011 17:25:00 -0600 Subject: forgot to get vm_opaque_ref --- nova/virt/xenapi/vmops.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3aa5a23e5..8abaa14fa 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -450,6 +450,7 @@ class VMOps(object): Creates vifs for an instance """ + vm_opaque_ref = self._get_vm_opaque_ref(instance.id) logging.debug(_("creating vif(s) for vm: |%s|"), vm_opaque_ref) if networks is None: networks = db.network_get_all_by_instance(admin_context, -- cgit From f7beae47ca505443eb86ea1a4fba6b47c1658755 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Thu, 24 Feb 2011 17:07:59 -0800 Subject: IPV6 FlatManager changes --- nova/virt/interfaces.template | 16 +++++++++++----- nova/virt/libvirt_conn.py | 27 +++++++++++++++++++-------- 2 files changed, 30 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/interfaces.template b/nova/virt/interfaces.template index 87b92b84a..1db745f9f 100644 --- a/nova/virt/interfaces.template +++ b/nova/virt/interfaces.template @@ -8,10 +8,16 @@ iface lo inet loopback # The primary network interface auto eth0 iface eth0 inet static - address %(address)s - netmask %(netmask)s - broadcast %(broadcast)s - gateway %(gateway)s - dns-nameservers %(dns)s + address ${address} + netmask ${netmask} + broadcast ${broadcast} + gateway ${gateway} + dns-nameservers ${dns} +#if $use_ipv6 +iface eth0 inet6 static + address ${addressv6} + netmask ${netmaskv6} + gateway ${gatewayv6} +#end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4e0fd106f..b7712f76e 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -146,6 +146,7 @@ class LibvirtConnection(object): self.libvirt_uri = self.get_uri() self.libvirt_xml = open(FLAGS.libvirt_xml_template).read() + self.interfaces_xml = open(FLAGS.injected_network_template).read() self._wrapped_conn = None self.read_only = read_only @@ -628,17 +629,27 @@ class LibvirtConnection(object): inst['id']) if network_ref['injected']: admin_context = context.get_admin_context() - address = db.instance_get_fixed_address(admin_context, inst['id']) + address = db.instance_get_fixed_address(admin_context, + inst['id']) + addressv6 = db.instance_get_fixed_address_v6(admin_context, + inst['id']) ra_server = network_ref['ra_server'] if not ra_server: ra_server = "fd00::" - with open(FLAGS.injected_network_template) as f: - net = f.read() % {'address': address, - 'netmask': network_ref['netmask'], - 'gateway': network_ref['gateway'], - 'broadcast': network_ref['broadcast'], - 'dns': network_ref['dns'], - 'ra_server': ra_server} + + interfaces_info = {'address': address, + 'netmask': network_ref['netmask'], + 'gateway': network_ref['gateway'], + 'broadcast': network_ref['broadcast'], + 'dns': network_ref['dns'], + 'ra_server': ra_server, + 'addressv6': addressv6, + 'gatewayv6': network_ref['gatewayv6'], + 'netmaskv6': network_ref['netmaskv6'], + 'use_ipv6': FLAGS.use_ipv6} + + net = str(Template(self.interfaces_xml, + searchList=[interfaces_info])) if key or net: inst_name = inst['name'] img_id = inst.image_id -- cgit From 6033f657aad9bd5b244a21908caedfc92840c9cf Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 25 Feb 2011 10:54:37 -0600 Subject: Create rescue instance --- nova/virt/xenapi/vmops.py | 69 ++++++++++++++++++++++++++--------------------- 1 file changed, 39 insertions(+), 30 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 0b9b7d0a4..d70129d80 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -65,20 +65,20 @@ class VMOps(object): def spawn(self, instance): """Create VM instance""" - vm = VMHelper.lookup(self._session, instance.name) + instance_name = instance.name + vm = VMHelper.lookup(self._session, instance_name) if vm is not None: raise exception.Duplicate(_('Attempted to create' - ' non-unique name %s') % instance.name) + ' non-unique name %s') % instance_name) #ensure enough free memory is available if not VMHelper.ensure_free_mem(self._session, instance): - name = instance['name'] - LOG.exception(_('instance %(name)s: not enough free memory') - % locals()) - db.instance_set_state(context.get_admin_context(), - instance['id'], - power_state.SHUTDOWN) - return + LOG.exception(_('instance %(instance_name)s: not enough free ' + 'memory') % locals()) + db.instance_set_state(context.get_admin_context(), + instance['id'], + power_state.SHUTDOWN) + return user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) @@ -150,9 +150,8 @@ class VMOps(object): LOG.debug(_('Starting VM %s...'), vm_ref) self._session.call_xenapi('VM.start', vm_ref, False, False) - instance_name = instance.name LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.') - % locals()) + % locals()) def _inject_onset_files(): onset_files = instance.onset_files @@ -176,18 +175,18 @@ class VMOps(object): def _wait_for_boot(): try: - state = self.get_info(instance['name'])['state'] + state = self.get_info(instance_name)['state'] db.instance_set_state(context.get_admin_context(), instance['id'], state) if state == power_state.RUNNING: - LOG.debug(_('Instance %s: booted'), instance['name']) + LOG.debug(_('Instance %s: booted'), instance_name) timer.stop() _inject_onset_files() return True except Exception, exc: LOG.warn(exc) LOG.exception(_('instance %s: failed to boot'), - instance['name']) + instance_name) db.instance_set_state(context.get_admin_context(), instance['id'], power_state.SHUTDOWN) @@ -475,24 +474,26 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" - #vm = self._get_vm_opaque_ref(instance) - #self._shutdown(instance, vm) + vm = self._get_vm_opaque_ref(instance) + self._shutdown(instance, vm) - print instance.__dict__ - print instance.name - print "%s-rescue" % instance.name - #rescue_vm = self.spawn(instance) + # log old instance + # log new instance - #vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] - #vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] - #vbd_ref = VMHelper.create_vbd( - # self._session, - # rescue_vm, - # vdi_ref, - # 1, - # False) + instance._rescue = True + self.spawn(instance) + rescue_vm = self._get_vm_opaque_ref(instance) - #self._session.call_xenapi("Async.VBD.plug", vbd_ref) + vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] + vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] + vbd_ref = VMHelper.create_vbd( + self._session, + rescue_vm, + vdi_ref, + 1, + False) + + self._session.call_xenapi("Async.VBD.plug", vbd_ref) def unrescue(self, instance, callback): """Unrescue the specified instance""" @@ -505,7 +506,15 @@ class VMOps(object): VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) - self.reboot(instance) + # fetch old instance + # fetch new instance + # destroy new instance + # start old instance + + self.destroy(instance) + instance._rescue = False + + self._start(instance, vm) def get_info(self, instance): """Return data about VM instance""" -- cgit From 2dc9d8bfe4bcd61c4d634767715b2be3a214426e Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 25 Feb 2011 12:43:09 -0600 Subject: Teardown rescue instance --- nova/virt/xenapi/vmops.py | 34 +++++++++++++++++++++------------- 1 file changed, 21 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 93c2ab0c7..6b531ca2c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -113,7 +113,7 @@ class VMOps(object): self.create_vifs(instance, networks) LOG.debug(_('Starting VM %s...'), vm_ref) - self._session.call_xenapi('VM.start', vm_ref, False, False) + self._start(instance, vm_ref) LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.') % locals()) @@ -438,12 +438,14 @@ class VMOps(object): def rescue(self, instance, callback): """Rescue the specified instance""" + rescue_vm = VMHelper.lookup(self._session, instance.name + "-rescue") + if rescue_vm: + raise RuntimeError(_( + "Instance is already in Rescue Mode: %s" % instance.name)) + vm = self._get_vm_opaque_ref(instance) self._shutdown(instance, vm) - # log old instance - # log new instance - instance._rescue = True self.spawn(instance) rescue_vm = self._get_vm_opaque_ref(instance) @@ -461,8 +463,16 @@ class VMOps(object): def unrescue(self, instance, callback): """Unrescue the specified instance""" - vm = self._get_vm_opaque_ref(instance) - vbds = self._session.get_xenapi().VM.get_VBDs(vm) + rescue_vm = VMHelper.lookup(self._session, instance.name + "-rescue") + + if not rescue_vm: + raise exception.NotFound(_( + "Instance is not in Rescue Mode: %s" % instance.name)) + + original_vm = self._get_vm_opaque_ref(instance) + vbds = self._session.get_xenapi().VM.get_VBDs(rescue_vm) + + instance._rescue = False for vbd_ref in vbds: vbd = self._session.get_xenapi().VBD.get_record(vbd_ref) @@ -470,15 +480,13 @@ class VMOps(object): VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) - # fetch old instance - # fetch new instance - # destroy new instance - # start old instance + task1 = self._session.call_xenapi("Async.VM.hard_shutdown", rescue_vm) + self._session.wait_for_task(task1, instance.id) - self.destroy(instance) - instance._rescue = False + task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm) + self._session.wait_for_task(task2, instance.id) - self._start(instance, vm) + self._start(instance, original_vm) def get_info(self, instance): """Return data about VM instance""" -- cgit From 6cfa479a1375fb8274dd9130946eab38e1398538 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 25 Feb 2011 14:35:29 -0600 Subject: Set rescue instance VIF device --- nova/virt/xenapi/vm_utils.py | 4 ++-- nova/virt/xenapi/vmops.py | 21 +++++++++++++++++++-- 2 files changed, 21 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 206201817..f0b1e993c 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -207,11 +207,11 @@ class VMHelper(HelperBase): raise StorageError(_('Unable to destroy VBD %s') % vbd_ref) @classmethod - def create_vif(cls, session, vm_ref, network_ref, mac_address): + def create_vif(cls, session, vm_ref, network_ref, mac_address, dev="0"): """Create a VIF record. Returns a Deferred that gives the new VIF reference.""" vif_rec = {} - vif_rec['device'] = '0' + vif_rec['device'] = dev vif_rec['network'] = network_ref vif_rec['VM'] = vm_ref vif_rec['MAC'] = mac_address diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6b531ca2c..c1e9bec62 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -483,6 +483,14 @@ class VMOps(object): task1 = self._session.call_xenapi("Async.VM.hard_shutdown", rescue_vm) self._session.wait_for_task(task1, instance.id) + vdis = VMHelper.lookup_vm_vdis(self._session, rescue_vm) + for vdi in vdis: + try: + task = self._session.call_xenapi('Async.VDI.destroy', vdi) + self._session.wait_for_task(task, instance.id) + except self.XenAPI.Failure: + continue + task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm) self._session.wait_for_task(task2, instance.id) @@ -574,8 +582,17 @@ class VMOps(object): NetworkHelper.find_network_with_bridge(self._session, bridge) if network_ref: - VMHelper.create_vif(self._session, vm_opaque_ref, - network_ref, instance.mac_address) + try: + device = "1" if instance._rescue else "0" + except AttributeError: + device = "0" + + VMHelper.create_vif( + self._session, + vm_opaque_ref, + network_ref, + instance.mac_address, + device) def reset_network(self, instance): """ -- cgit From 7ad2e0a731e6b2fbace8528439f6a8c2f0d5aaad Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 25 Feb 2011 14:47:25 -0600 Subject: Removed unnecessary compute import --- nova/virt/xenapi/vmops.py | 2 -- 1 file changed, 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index c1e9bec62..3e3c9ff6e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -27,7 +27,6 @@ import tempfile import uuid from nova import db -from nova import compute from nova import context from nova import log as logging from nova import exception @@ -50,7 +49,6 @@ class VMOps(object): def __init__(self, session): self.XenAPI = session.get_imported_xenapi() self._session = session - self.compute_api = compute.API() VMHelper.XenAPI = self.XenAPI -- cgit From 97566c04b3a04626f1bc1b66e72c61b4621b6c7d Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 25 Feb 2011 16:18:11 -0600 Subject: Bootlock original instance during rescue --- nova/virt/xenapi/vmops.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3e3c9ff6e..21477a18c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -196,6 +196,19 @@ class VMOps(object): _('Instance not present %s') % instance_name) return vm + def _bootlock(self, vm, unlock=False): + """Prevent an instance from booting""" + if unlock: + self._session.call_xenapi( + "VM.remove_from_blocked_operations", + vm, + "start") + else: + self._session.call_xenapi( + "VM.set_blocked_operations", + vm, + {"start": ""}) + def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance @@ -443,6 +456,7 @@ class VMOps(object): vm = self._get_vm_opaque_ref(instance) self._shutdown(instance, vm) + self._bootlock(vm) instance._rescue = True self.spawn(instance) @@ -492,6 +506,7 @@ class VMOps(object): task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm) self._session.wait_for_task(task2, instance.id) + self._bootlock(original_vm, unlock=True) self._start(instance, original_vm) def get_info(self, instance): -- cgit From 4c83130464c88650df7dfc7974f2fd088a733fec Mon Sep 17 00:00:00 2001 From: Christian Berendt Date: Sat, 26 Feb 2011 17:26:38 +0100 Subject: introduced new flag "maximum_nbd_devices" to set the number of possible NBD devices --- nova/virt/disk.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index cb639a102..8789d8123 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -40,6 +40,8 @@ flags.DEFINE_integer('block_size', 1024 * 1024 * 256, 'block_size to use for dd') flags.DEFINE_integer('timeout_nbd', 10, 'time to wait for a NBD device coming up') +flags.DEFINE_integer('maximum_nbd_devices', 16, + 'maximum number of possible nbd devices') def extend(image, size): @@ -141,7 +143,7 @@ def _unlink_device(device, nbd): utils.execute('sudo losetup --detach %s' % device) -_DEVICES = ['/dev/nbd%s' % i for i in xrange(16)] +_DEVICES = ['/dev/nbd%s' % i for i in xrange(FLAGS.maximum_nbd_devices)] def _allocate_device(): -- cgit From dcfa9670a669ff881865750b2f96f62195dce2df Mon Sep 17 00:00:00 2001 From: Christian Berendt Date: Sat, 26 Feb 2011 19:19:02 +0100 Subject: renamed flag from maximum_... to max_... --- nova/virt/disk.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 8789d8123..2bded07a4 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -40,7 +40,7 @@ flags.DEFINE_integer('block_size', 1024 * 1024 * 256, 'block_size to use for dd') flags.DEFINE_integer('timeout_nbd', 10, 'time to wait for a NBD device coming up') -flags.DEFINE_integer('maximum_nbd_devices', 16, +flags.DEFINE_integer('max_nbd_devices', 16, 'maximum number of possible nbd devices') @@ -143,7 +143,7 @@ def _unlink_device(device, nbd): utils.execute('sudo losetup --detach %s' % device) -_DEVICES = ['/dev/nbd%s' % i for i in xrange(FLAGS.maximum_nbd_devices)] +_DEVICES = ['/dev/nbd%s' % i for i in xrange(FLAGS.max_nbd_devices)] def _allocate_device(): -- cgit From 1278af43c16daea1bcbd2d47cd2d81919fe2c37e Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Sun, 27 Feb 2011 12:51:19 -0500 Subject: Add lxc libvirt driver --- nova/virt/libvirt.xml.template | 14 ++++++++++++++ nova/virt/libvirt_conn.py | 13 +++++++++++-- 2 files changed, 25 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 88bfbc668..87dea9039 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -2,6 +2,12 @@ ${name} ${memory_kb} +#if $type == 'lxc' + #set $disk_prefix = '' + #set $disk_bus = '' + exe + /sbin/init +#else #if $type == 'uml' #set $disk_prefix = 'ubd' #set $disk_bus = 'uml' @@ -37,6 +43,7 @@ #end if #end if + #end if #end if @@ -44,6 +51,12 @@ ${vcpus} +#if $type == 'lxc' + + + + +#else #if $getVar('rescue', False) @@ -68,6 +81,7 @@ #end if + #end if #end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4e0fd106f..f97c10765 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -20,7 +20,7 @@ """ A connection to a hypervisor through libvirt. -Supports KVM, QEMU, UML, and XEN. +Supports KVM, LXC, QEMU, UML, and XEN. **Related Flags** @@ -83,7 +83,7 @@ flags.DEFINE_string('libvirt_xml_template', flags.DEFINE_string('libvirt_type', 'kvm', 'Libvirt domain type (valid options are: ' - 'kvm, qemu, uml, xen)') + 'kvm, lxc, qemu, uml, xen)') flags.DEFINE_string('libvirt_uri', '', 'Override the default libvirt URI (which is dependent' @@ -202,6 +202,8 @@ class LibvirtConnection(object): uri = FLAGS.libvirt_uri or 'uml:///system' elif FLAGS.libvirt_type == 'xen': uri = FLAGS.libvirt_uri or 'xen:///' + elif FLAGS.libvirt_type == 'lxc': + uri = FLAGS.libvirt_uri or 'lxc:///' else: uri = FLAGS.libvirt_uri or 'qemu:///system' return uri @@ -565,6 +567,10 @@ class LibvirtConnection(object): f.write(libvirt_xml) f.close() + if FLAGS.libvirt_type == 'lxc': + container_dir = '%s/rootfs' % basepath(suffix='') + utils.execute('mkdir -p %s' % container_dir) + # NOTE(vish): No need add the suffix to console.log os.close(os.open(basepath('console.log', ''), os.O_CREAT | os.O_WRONLY, 0660)) @@ -622,6 +628,9 @@ class LibvirtConnection(object): if not inst['kernel_id']: target_partition = "1" + if FLAGS.libvirt_type == 'lxc': + target_partition = None + key = str(inst['key_data']) net = None network_ref = db.network_get_by_instance(context.get_admin_context(), -- cgit From 2d6987d8c33477af19179e7664bbedf689bc08dc Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Sun, 27 Feb 2011 13:05:26 -0500 Subject: Add ability to mount containers --- nova/virt/disk.py | 26 ++++++++++++++++++++++++++ nova/virt/libvirt_conn.py | 6 ++++++ 2 files changed, 32 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 2bded07a4..7cbc4a3be 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -114,6 +114,32 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): _unlink_device(device, nbd) +def setup_container(image, container_dir=None, partition=None, nbd=False): + """Setup the LXC container + + It will mount the loopback image to the container directory in order + to create the root filesystem for the container + """ + device = _link_device(image, nbd) + try: + if not partition is None: + # create partition + utils.execute('sudo kpartx -a %s' % device) + mapped_device = '/dev/mapper/%p%s' % (device.split('/')[-1], + partition) + else: + mapped_device = device + + utils.execute('sudo mount %s %s' %(mapped_device, container_dir)) + + except Exception as e: + LOG.warn(_('Unable to mount container')) + if not partition is None: + # remove partitions + utils.execute('sudo kpartx -s %s' % device) + _unlink_device(device, nbd) + + def _link_device(image, nbd): """Link image to device using loopback or nbd""" if nbd: diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index f97c10765..f7807a851 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -661,6 +661,12 @@ class LibvirtConnection(object): disk.inject_data(basepath('disk'), key, net, partition=target_partition, nbd=FLAGS.use_cow_images) + + if FLAGS.libvirt_type == 'lxc': + disk.setup_container(basepath('disk'), + container_dir=container_dir, + partition=target_partition, + nbd=FLAGS.use_cow_images) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' -- cgit From 33d7edb9d02d8f4dcb0b6ee85caf10434f060e1b Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Sun, 27 Feb 2011 13:29:05 -0500 Subject: Clean up the mount points when it shutsdown --- nova/virt/disk.py | 1 - nova/virt/libvirt_conn.py | 2 ++ 2 files changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 7cbc4a3be..28a4c11fb 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -139,7 +139,6 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): utils.execute('sudo kpartx -s %s' % device) _unlink_device(device, nbd) - def _link_device(image, nbd): """Link image to device using loopback or nbd""" if nbd: diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index f7807a851..5e76edb0b 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -259,6 +259,8 @@ class LibvirtConnection(object): instance_name = instance['name'] LOG.info(_('instance %(instance_name)s: deleting instance files' ' %(target)s') % locals()) + if FLAGS.libvirt_type == 'lxc': + utils.execute('sudo umount %s/rootfs' % target) if os.path.exists(target): shutil.rmtree(target) -- cgit From 72940957611bcba7dc41bfe9232743369d9a151f Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Mon, 28 Feb 2011 16:04:26 +0000 Subject: Fixed default value for xenapi_agent_path flag --- nova/virt/xenapi_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 546a10d09..4fc69961d 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -106,7 +106,7 @@ flags.DEFINE_integer('xenapi_inject_image', ' data into the disk image should be made.' ' Used only if connection_type=xenapi.') flags.DEFINE_integer('xenapi_agent_path', - True, + '/usr/sbin/xe-update-networking' 'Specifies the path in which the xenapi guest agent' ' should be located. If the agent is present,' ' network configuration if not injected into the image' -- cgit From 026c83551fa2e07f7f20d6b163f7da93e331b084 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Mon, 28 Feb 2011 16:59:00 +0000 Subject: Fixed obvious errors with flags. Note: tests still fail. --- nova/virt/xenapi_conn.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 4fc69961d..b9e87c2ce 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -100,13 +100,13 @@ flags.DEFINE_integer('xenapi_vhd_coalesce_max_attempts', 5, 'Max number of times to poll for VHD to coalesce.' ' Used only if connection_type=xenapi.') -flags.DEFINE_integer('xenapi_inject_image', +flags.DEFINE_bool('xenapi_inject_image', True, 'Specifies whether an attempt to inject network/key' ' data into the disk image should be made.' ' Used only if connection_type=xenapi.') -flags.DEFINE_integer('xenapi_agent_path', - '/usr/sbin/xe-update-networking' +flags.DEFINE_string('xenapi_agent_path', + '/usr/sbin/xe-update-networking', 'Specifies the path in which the xenapi guest agent' ' should be located. If the agent is present,' ' network configuration if not injected into the image' -- cgit From 8da6796789767b1341cb5a650066b67ad3191c74 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 28 Feb 2011 12:30:02 -0600 Subject: Merge review fixes --- nova/virt/xenapi/vm_utils.py | 17 ++++++++++++++--- nova/virt/xenapi/vmops.py | 27 +++++++++++++++++---------- 2 files changed, 31 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index e7ad1f686..870660dea 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -300,6 +300,13 @@ class VMHelper(HelperBase): the UUID """ return session.call_xenapi('SR.get_by_name_label', sr_label)[0] + @classmethod + def get_sr_path(cls, session, sr_label='slices'): + """ Finds the SR and then coerces it into a path on the dom0 file + system """ + # TODO(mdietz): replace this with the flag once unified-images merges + return '/var/run/sr-mount/%s' % cls.get_sr(session, sr_label) + @classmethod def upload_image(cls, session, instance_id, vdi_uuids, image_id): """ Requests that the Glance plugin bundle the specified VDIs and @@ -508,13 +515,17 @@ class VMHelper(HelperBase): @classmethod def scan_sr(cls, session, instance_id=None, sr_ref=None): + """Scans the SR specified by sr_ref""" if sr_ref: LOG.debug(_("Re-scanning SR %s"), sr_ref) task = session.call_xenapi('Async.SR.scan', sr_ref) session.wait_for_task(instance_id, task) - else: - sr_ref = cls.get_sr(session) - session.call_xenapi('SR.scan', sr_ref) + + @classmethod + def scan_default_sr(cls, session): + """Looks for the system default SR and triggers a re-scan""" + sr_ref = cls.get_sr(session) + session.call_xenapi('SR.scan', sr_ref) def get_rrd(host, uuid): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index f5278ff07..b3e5627d8 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -298,8 +298,10 @@ class VMOps(object): VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) cow_uuid = vm_vdi_rec['uuid'] - params = {'host': dest, 'vdi_uuid': base_copy_uuid, - 'instance_id': instance.id, } + params = {'host': dest, + 'vdi_uuid': base_copy_uuid, + 'instance_id': instance.id, + 'sr_path': VMHelper.get_sr_path(self._session), } task = self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) @@ -308,8 +310,11 @@ class VMOps(object): # Now power down the instance and transfer the COW VHD self._shutdown(instance, vm_ref, method='clean') - params = {'host': dest, 'vdi_uuid': cow_uuid, - 'instance_id': instance.id, } + params = {'host': dest, + 'vdi_uuid': cow_uuid, + 'instance_id': instance.id, + 'sr_path': VMHelper.get_sr_path(self._session), } + task = self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) self._session.wait_for_task(instance.id, task) @@ -326,14 +331,15 @@ class VMOps(object): 'old_base_copy_uuid': disk_info['base_copy'], 'old_cow_uuid': disk_info['cow'], 'new_base_copy_uuid': new_base_copy_uuid, - 'new_cow_uuid': new_cow_uuid, } + 'new_cow_uuid': new_cow_uuid, + 'sr_path': VMHelper.get_sr_path(self._session), } task = self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) self._session.wait_for_task(instance.id, task) # Now we rescan the SR so we find the VHDs - VMHelper.scan_sr(self._session) + VMHelper.scan_default_sr(self._session) return new_cow_uuid @@ -411,7 +417,7 @@ class VMOps(object): raise RuntimeError(resp_dict['message']) return resp_dict['message'] - def _shutdown(self, instance, vm, method='hard'): + def _shutdown(self, instance, vm, hard=True): """Shutdown an instance """ state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: @@ -421,10 +427,11 @@ class VMOps(object): try: task = None - if method == 'clean': - task = self._session.call_xenapi('Async.VM.clean_shutdown', vm) - else: + if hard: task = self._session.call_xenapi('Async.VM.hard_shutdown', vm) + else: + task = self._session.call_xenapi('Async.VM.clean_shutdown', vm) + self._session.wait_for_task(instance.id, task) except self.XenAPI.Failure, exc: LOG.exception(exc) -- cgit From 4e4711ccfc7ce3c3df704a8635dccd506d6e7f01 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Tue, 1 Mar 2011 00:28:59 +0000 Subject: Units tests fixed partially. Still need to address checking data injected into xenstore need to convert string into dict or similar. Also todo PEP8 fixes --- nova/virt/xenapi/fake.py | 9 +++++++++ nova/virt/xenapi/vm_utils.py | 3 ++- nova/virt/xenapi/vmops.py | 7 +++++++ nova/virt/xenapi_conn.py | 2 +- 4 files changed, 19 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 08e2a03f7..664cfbd79 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -153,7 +153,14 @@ def VM_get_xenstore_data(vm_ref): return _db_content['VM'][vm_ref].get('xenstore_data', '') +def VM_remove_from_xenstore_data(vm_ref, key): + db_ref = _db_content['VM'][vm_ref] + if not 'xenstore_data' in db_ref: + return + db_ref['xenstore_data'][key] = None + def VM_add_to_xenstore_data(vm_ref, key, value): + LOG.debug("ADDING TO XENSTORE DATA %s %s",key,value) db_ref = _db_content['VM'][vm_ref] if not 'xenstore_data' in db_ref: db_ref['xenstore_data'] = {} @@ -503,7 +510,9 @@ class SessionBase(object): def _get_by_field(self, recs, k, v, return_singleton): result = [] + LOG.debug("_get_by_field!!!! - %d", return_singleton) for ref, rec in recs.iteritems(): + LOG.debug("k:%s,rec[k]:%s,v:%s",k,rec.get(k),v) if rec.get(k) == v: result.append(ref) diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 0434f745d..a01bab8de 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -409,8 +409,10 @@ class VMHelper(HelperBase): @classmethod def lookup(cls, session, i): """Look the instance i up, and returns it if available""" + LOG.debug("Entering lookup for instance:%s",str(i)) vms = session.get_xenapi().VM.get_by_name_label(i) n = len(vms) + LOG.debug("n:%d",n) if n == 0: return None elif n > 1: @@ -480,7 +482,6 @@ class VMHelper(HelperBase): else: try: # This try block ensures that the umount occurs - xe_guest_agent_filename = os.path.join( tmpdir, FLAGS.xenapi_agent_path) if os.path.isfile(xe_guest_agent_filename): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index cc84b7032..c137d4931 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -117,6 +117,7 @@ class VMOps(object): VMHelper.preconfigure_instance(self._session, instance, vdi_ref) # inject_network_info and create vifs + LOG.debug("About to run inject_network_info") networks = self.inject_network_info(instance) self.create_vifs(instance, networks) @@ -186,6 +187,7 @@ class VMOps(object): # Must be the instance name instance_name = instance_or_vm except (AttributeError, KeyError): + # # Note the the KeyError will only happen with fakes.py # Not a string; must be an ID or a vm instance if isinstance(instance_or_vm, (int, long)): @@ -201,8 +203,12 @@ class VMOps(object): instance_name = instance_or_vm else: instance_name = instance_or_vm.name + #fake xenapi does not use OpaqueRef as a prefix + #when running tests we will always end up here vm = VMHelper.lookup(self._session, instance_name) if vm is None: + if FLAGS.xenapi_connection_url == 'test_url': + return instance_or_vm raise exception.NotFound( _('Instance not present %s') % instance_name) return vm @@ -496,6 +502,7 @@ class VMOps(object): 'ips': [ip_dict(ip) for ip in network_IPs]} self.write_to_param_xenstore(vm_opaque_ref, {location: mapping}) try: + logging.debug("About to run write_to_xenstore") self.write_to_xenstore(vm_opaque_ref, location, mapping['location']) except KeyError: diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index b9e87c2ce..9f8b6af02 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -106,7 +106,7 @@ flags.DEFINE_bool('xenapi_inject_image', ' data into the disk image should be made.' ' Used only if connection_type=xenapi.') flags.DEFINE_string('xenapi_agent_path', - '/usr/sbin/xe-update-networking', + 'usr/sbin/xe-update-networking', 'Specifies the path in which the xenapi guest agent' ' should be located. If the agent is present,' ' network configuration if not injected into the image' -- cgit From 8806858918f396cfca41a28c191dc9e8d2809a0e Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Tue, 1 Mar 2011 01:10:38 +0000 Subject: Fixed xenapi tests Gave up on clever things with map stored as string in xenstore. Used ast.liteeral_eval instead. Changed instance ID and names in tests from in to string (1 => '1') This simplified VMOps._get_vm_opaqueref Changed VMOps._get_vm_opaqueref as references returned by fake xenapi do not start with "OpaqueRef:" prefix. Fixed PEP8 Errors --- nova/virt/xenapi/fake.py | 6 ++---- nova/virt/xenapi/vm_utils.py | 8 -------- nova/virt/xenapi/vmops.py | 15 +++------------ 3 files changed, 5 insertions(+), 24 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 664cfbd79..7aa82211d 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -156,11 +156,11 @@ def VM_get_xenstore_data(vm_ref): def VM_remove_from_xenstore_data(vm_ref, key): db_ref = _db_content['VM'][vm_ref] if not 'xenstore_data' in db_ref: - return + return db_ref['xenstore_data'][key] = None + def VM_add_to_xenstore_data(vm_ref, key, value): - LOG.debug("ADDING TO XENSTORE DATA %s %s",key,value) db_ref = _db_content['VM'][vm_ref] if not 'xenstore_data' in db_ref: db_ref['xenstore_data'] = {} @@ -510,9 +510,7 @@ class SessionBase(object): def _get_by_field(self, recs, k, v, return_singleton): result = [] - LOG.debug("_get_by_field!!!! - %d", return_singleton) for ref, rec in recs.iteritems(): - LOG.debug("k:%s,rec[k]:%s,v:%s",k,rec.get(k),v) if rec.get(k) == v: result.append(ref) diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index a01bab8de..510261b15 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -409,10 +409,8 @@ class VMHelper(HelperBase): @classmethod def lookup(cls, session, i): """Look the instance i up, and returns it if available""" - LOG.debug("Entering lookup for instance:%s",str(i)) vms = session.get_xenapi().VM.get_by_name_label(i) n = len(vms) - LOG.debug("n:%d",n) if n == 0: return None elif n > 1: @@ -451,20 +449,17 @@ class VMHelper(HelperBase): # As mounting the image VDI is expensive, we only want do do it once, # if at all, so determine whether it's required first, and then do # everything - LOG.debug("Running preconfigure_instance") mount_required = False key, net = disk.get_injectables(instance) if key is not None or net is not None: mount_required = True - LOG.debug("Mount_required:%s", str(mount_required)) if mount_required: def _mounted_processing(device): """Callback which runs with the image VDI attached""" dev_path = '/dev/' + device + '1' # NB: Partition 1 hardcoded - LOG.debug("Device path:%s", dev_path) tmpdir = tempfile.mkdtemp() try: # Mount only Linux filesystems, to avoid disturbing @@ -473,7 +468,6 @@ class VMHelper(HelperBase): out, err = utils.execute( 'sudo mount -t ext2,ext3 "%s" "%s"' % (dev_path, tmpdir)) - LOG.debug("filesystem mounted") except exception.ProcessExecutionError as e: err = str(e) if err: @@ -506,7 +500,6 @@ class VMHelper(HelperBase): 'installed in this image')) LOG.info(_('Manipulating interface files ' 'directly')) - LOG.debug("Going to inject data in filesystem") disk.inject_data_into_fs(tmpdir, key, net, utils.execute) finally: @@ -748,7 +741,6 @@ def vbd_unplug_with_retry(session, vbd): # FIXME(sirp): We can use LoopingCall here w/o blocking sleep() while True: try: - LOG.debug("About to unplug VBD") session.get_xenapi().VBD.unplug(vbd) LOG.debug(_('VBD.unplug successful first time.')) return diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index c137d4931..a2f3a8f09 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -112,12 +112,10 @@ class VMOps(object): # Alter the image before VM start for, e.g. network injection #TODO(salvatore-orlando): do this only if flag is true - LOG.debug("About to run preconfigure_instance") if FLAGS.xenapi_inject_image: VMHelper.preconfigure_instance(self._session, instance, vdi_ref) # inject_network_info and create vifs - LOG.debug("About to run inject_network_info") networks = self.inject_network_info(instance) self.create_vifs(instance, networks) @@ -192,19 +190,12 @@ class VMOps(object): # Not a string; must be an ID or a vm instance if isinstance(instance_or_vm, (int, long)): ctx = context.get_admin_context() - try: - instance_obj = db.instance_get(ctx, instance_or_vm) - instance_name = instance_obj.name - except exception.NotFound: - # The unit tests screw this up, as they use an integer for - # the vm name. I'd fix that up, but that's a matter for - # another bug report. So for now, just try with the passed - # value - instance_name = instance_or_vm + instance_obj = db.instance_get(ctx, instance_or_vm) + instance_name = instance_obj.name else: instance_name = instance_or_vm.name #fake xenapi does not use OpaqueRef as a prefix - #when running tests we will always end up here + #when running tests we will always end up here vm = VMHelper.lookup(self._session, instance_name) if vm is None: if FLAGS.xenapi_connection_url == 'test_url': -- cgit From fbcbf5ef805748bea29e4135ee8989830064c273 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Tue, 1 Mar 2011 10:55:13 -0600 Subject: Fixed trunk merge issues --- nova/virt/xenapi/vm_utils.py | 2 +- nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 527d8700c..977c19359 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -343,7 +343,7 @@ class VMHelper(HelperBase): kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'download_vhd', kwargs) - vdi_uuid = session.wait_for_task(instance_id, task) + vdi_uuid = session.wait_for_task(task, instance_id) scan_sr(session, instance_id, sr_ref) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 43b63bfd8..a3379fa7f 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -411,7 +411,7 @@ class VMOps(object): args = {'kernel-file': kernel, 'ramdisk-file': ramdisk} task = self._session.async_call_plugin( 'glance', 'remove_kernel_ramdisk', args) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) LOG.debug(_("kernel/ramdisk files removed")) -- cgit From f952992f035ec130b7608e9851ef9c3becc2047a Mon Sep 17 00:00:00 2001 From: sateesh Date: Wed, 2 Mar 2011 00:43:29 +0530 Subject: Updated the code to include support for guest consoles, VLAN networking for guest machines on ESX/ESXi servers as compute providers in OpenStack. Removed dependency on ZSI and now using suds-0.4 to generate the required stubs for VMware Virtual Infrastructure API on the fly for calls by vmwareapi module. --- nova/virt/vmwareapi/__init__.py | 9 - nova/virt/vmwareapi/fake.py | 684 +++++++++++++++++++++++++++++++++ nova/virt/vmwareapi/io_util.py | 52 +-- nova/virt/vmwareapi/network_utils.py | 117 ++++++ nova/virt/vmwareapi/read_write_util.py | 110 ++---- nova/virt/vmwareapi/vim.py | 117 +++--- nova/virt/vmwareapi/vim_util.py | 303 +++++++-------- nova/virt/vmwareapi/vm_util.py | 335 ++++++++-------- nova/virt/vmwareapi/vmops.py | 435 ++++++++++----------- nova/virt/vmwareapi/vmware_images.py | 96 +---- nova/virt/vmwareapi_conn.py | 134 +++---- 11 files changed, 1490 insertions(+), 902 deletions(-) create mode 100644 nova/virt/vmwareapi/fake.py create mode 100644 nova/virt/vmwareapi/network_utils.py (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/__init__.py b/nova/virt/vmwareapi/__init__.py index 0cf70150c..27e212a30 100644 --- a/nova/virt/vmwareapi/__init__.py +++ b/nova/virt/vmwareapi/__init__.py @@ -14,16 +14,7 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. - """ :mod:`vmwareapi` -- Nova support for VMware ESX/ESXi Server through vSphere API -=============================================================================== """ - -class HelperBase(object): - """The base for helper classes. This adds the VMwareAPI class attribute""" - VMwareAPI = None - - def __init__(self): - return diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py new file mode 100644 index 000000000..43a2f1943 --- /dev/null +++ b/nova/virt/vmwareapi/fake.py @@ -0,0 +1,684 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +A fake VMWare VI API implementation. +""" + +from pprint import pformat +import uuid + +from nova import exception +from nova import log as logging +from nova.virt.vmwareapi import vim +from nova.virt.vmwareapi.vim import SessionFaultyException + +_CLASSES = ['Datacenter', 'Datastore', 'ResourcePool', 'VirtualMachine', + 'Network', 'HostSystem', 'Task', 'session', 'files'] + +_FAKE_FILE_SIZE = 1024 + +_db_content = {} + +LOG = logging.getLogger("nova.virt.vmwareapi.fake") + + +def log_db_contents(msg=None): + """ Log DB Contents""" + text = msg or "" + content = pformat(_db_content) + LOG.debug(_("%(text)s: _db_content => %(content)s") % locals()) + + +def reset(): + """ Resets the db contents """ + for c in _CLASSES: + #We fake the datastore by keeping the file references as a list of + #names in the db + if c == 'files': + _db_content[c] = [] + else: + _db_content[c] = {} + create_network() + create_host() + create_datacenter() + create_datastore() + create_res_pool() + + +def cleanup(): + """ Clear the db contents """ + for c in _CLASSES: + _db_content[c] = {} + + +def _create_object(table, obj): + """ Create an object in the db """ + _db_content[table][obj.obj] = obj + + +def _get_objects(type): + """ Get objects of the type """ + lst_objs = [] + for key in _db_content[type]: + lst_objs.append(_db_content[type][key]) + return lst_objs + + +class Prop(object): + """ Property Object base class """ + + def __init__(self): + self.name = None + self.val = None + + def setVal(self, val): + self.val = val + + def setName(self, name): + self.name = name + + +class ManagedObject(object): + """ Managed Data Object base class """ + + def __init__(self, name="ManagedObject", obj_ref=None): + """ Sets the obj property which acts as a reference to the object""" + object.__setattr__(self, 'objName', name) + if obj_ref is None: + obj_ref = str(uuid.uuid4()) + object.__setattr__(self, 'obj', obj_ref) + object.__setattr__(self, 'propSet', []) + + def set(self, attr, val): + """ Sets an attribute value. Not using the __setattr__ directly for we + want to set attributes of the type 'a.b.c' and using this function + class we set the same """ + self.__setattr__(attr, val) + + def get(self, attr): + """ Gets an attribute. Used as an intermediary to get nested + property like 'a.b.c' value """ + return self.__getattr__(attr) + + def __setattr__(self, attr, val): + for prop in self.propSet: + if prop.name == attr: + prop.val = val + return + elem = Prop() + elem.setName(attr) + elem.setVal(val) + self.propSet.append(elem) + + def __getattr__(self, attr): + for elem in self.propSet: + if elem.name == attr: + return elem.val + raise Exception(_("Property %(attr)s not set for the managed " + "object %(objName)s") % + {'attr': attr, + 'objName': self.objName}) + + +class DataObject(object): + """ Data object base class """ + + def __init__(self): + pass + + def __getattr__(self, attr): + return object.__getattribute__(self, attr) + + def __setattr__(self, attr, value): + object.__setattr__(self, attr, value) + + +class VirtualDisk(DataObject): + """ Virtual Disk class. Does nothing special except setting + __class__.__name__ to 'VirtualDisk'. Refer place where __class__.__name__ + is used in the code """ + + def __init__(self): + DataObject.__init__(self) + + +class VirtualDiskFlatVer2BackingInfo(DataObject): + """ VirtualDiskFlatVer2BackingInfo class """ + + def __init__(self): + DataObject.__init__(self) + + +class VirtualLsiLogicController(DataObject): + """ VirtualLsiLogicController class """ + + def __init__(self): + DataObject.__init__(self) + + +class VirtualMachine(ManagedObject): + """ Virtual Machine class """ + + def __init__(self, **kwargs): + ManagedObject.__init__(self, "VirtualMachine") + self.set("name", kwargs.get("name")) + self.set("runtime.connectionState", + kwargs.get("conn_state", "connected")) + self.set("summary.config.guestId", kwargs.get("guest", "otherGuest")) + ds_do = DataObject() + ds_do.ManagedObjectReference = [kwargs.get("ds").obj] + self.set("datastore", ds_do) + self.set("summary.guest.toolsStatus", kwargs.get("toolsstatus", + "toolsOk")) + self.set("runtime.powerState", kwargs.get("powerstate", "poweredOn")) + self.set("config.files.vmPathName", kwargs.get("vmPathName")) + self.set("summary.config.numCpu", kwargs.get("numCpu", 1)) + self.set("summary.config.memorySizeMB", kwargs.get("mem", 1)) + self.set("config.hardware.device", kwargs.get("virtual_disk", None)) + self.set("config.extraConfig", kwargs.get("extra_config", None)) + + def reconfig(self, factory, val): + """ Called to reconfigure the VM. Actually customizes the property + setting of the Virtual Machine object """ + try: + #Case of Reconfig of VM to attach disk + controller_key = val.deviceChange[1].device.controllerKey + filename = val.deviceChange[1].device.backing.fileName + + disk = VirtualDisk() + disk.controllerKey = controller_key + + disk_backing = VirtualDiskFlatVer2BackingInfo() + disk_backing.fileName = filename + disk_backing.key = -101 + disk.backing = disk_backing + + controller = VirtualLsiLogicController() + controller.key = controller_key + + self.set("config.hardware.device", [disk, controller]) + except Exception: + #Case of Reconfig of VM to set extra params + self.set("config.extraConfig", val.extraConfig) + + +class Network(ManagedObject): + """ Network class """ + + def __init__(self): + ManagedObject.__init__(self, "Network") + self.set("summary.name", "vmnet0") + + +class ResourcePool(ManagedObject): + """ Resource Pool class """ + + def __init__(self): + ManagedObject.__init__(self, "ResourcePool") + self.set("name", "ResPool") + + +class Datastore(ManagedObject): + """ Datastore class """ + + def __init__(self): + ManagedObject.__init__(self, "Datastore") + self.set("summary.type", "VMFS") + self.set("summary.name", "fake-ds") + + +class HostSystem(ManagedObject): + """ Host System class """ + + def __init__(self): + ManagedObject.__init__(self, "HostSystem") + self.set("name", "HostSystem") + self.set("configManager.networkSystem", "NetworkSystem") + + vswitch_do = DataObject() + vswitch_do.pnic = ["vmnic0"] + vswitch_do.name = "vSwitch0" + vswitch_do.portgroup = ["PortGroup-vmnet0"] + + net_swicth = DataObject() + net_swicth.HostVirtualSwitch = [vswitch_do] + self.set("config.network.vswitch", net_swicth) + + host_pg_do = DataObject() + host_pg_do.key = "PortGroup-vmnet0" + + pg_spec = DataObject() + pg_spec.vlanId = 0 + pg_spec.name = "vmnet0" + + host_pg_do.spec = pg_spec + + host_pg = DataObject() + host_pg.HostPortGroup = [host_pg_do] + self.set("config.network.portgroup", host_pg) + + def _add_port_group(self, spec): + """ Adds a port group to the host system object in the db """ + pg_name = spec.name + vswitch_name = spec.vswitchName + vlanid = spec.vlanId + + vswitch_do = DataObject() + vswitch_do.pnic = ["vmnic0"] + vswitch_do.name = vswitch_name + vswitch_do.portgroup = ["PortGroup-%s" % pg_name] + + vswitches = self.get("config.network.vswitch").HostVirtualSwitch + vswitches.append(vswitch_do) + + host_pg_do = DataObject() + host_pg_do.key = "PortGroup-%s" % pg_name + + pg_spec = DataObject() + pg_spec.vlanId = vlanid + pg_spec.name = pg_name + + host_pg_do.spec = pg_spec + host_pgrps = self.get("config.network.portgroup").HostPortGroup + host_pgrps.append(host_pg_do) + + +class Datacenter(ManagedObject): + """ Datacenter class """ + + def __init__(self): + ManagedObject.__init__(self, "Datacenter") + self.set("name", "ha-datacenter") + self.set("vmFolder", "vm_folder_ref") + if _db_content.get("Network", None) is None: + create_network() + net_ref = _db_content["Network"][_db_content["Network"].keys()[0]].obj + network_do = DataObject() + network_do.ManagedObjectReference = [net_ref] + self.set("network", network_do) + + +class Task(ManagedObject): + """ Task class """ + + def __init__(self, task_name, state="running"): + ManagedObject.__init__(self, "Task") + info = DataObject + info.name = task_name + info.state = state + self.set("info", info) + + +def create_host(): + host_system = HostSystem() + _create_object('HostSystem', host_system) + + +def create_datacenter(): + data_center = Datacenter() + _create_object('Datacenter', data_center) + + +def create_datastore(): + data_store = Datastore() + _create_object('Datastore', data_store) + + +def create_res_pool(): + res_pool = ResourcePool() + _create_object('ResourcePool', res_pool) + + +def create_network(): + network = Network() + _create_object('Network', network) + + +def create_task(task_name, state="running"): + task = Task(task_name, state) + _create_object("Task", task) + return task + + +def _add_file(file_path): + """ Adds a file reference to the db """ + _db_content["files"].append(file_path) + + +def _remove_file(file_path): + """ Removes a file reference from the db """ + if _db_content.get("files", None) is None: + raise Exception(_("No files have been added yet")) + #Check if the remove is for a single file object or for a folder + if file_path.find(".vmdk") != -1: + if file_path not in _db_content.get("files"): + raise Exception(_("File- '%s' is not there in the datastore") %\ + file_path) + _db_content.get("files").remove(file_path) + else: + #Removes the files in the folder and the folder too from the db + for file in _db_content.get("files"): + if file.find(file_path) != -1: + try: + _db_content.get("files").remove(file) + except Exception: + pass + + +def fake_fetch_image(image, instance, **kwargs): + """Fakes fetch image call. Just adds a reference to the db for the file """ + ds_name = kwargs.get("datastore_name") + file_path = kwargs.get("file_path") + ds_file_path = "[" + ds_name + "] " + file_path + _add_file(ds_file_path) + + +def fake_upload_image(image, instance, **kwargs): + """Fakes the upload of an image """ + pass + + +def fake_get_vmdk_size_and_properties(image_id, instance): + """ Fakes the file size and properties fetch for the image file """ + props = {"vmware_ostype": "otherGuest", + "vmware_adaptertype": "lsiLogic"} + return _FAKE_FILE_SIZE, props + + +def _get_vm_mdo(vm_ref): + """ Gets the Virtual Machine with the ref from the db """ + if _db_content.get("VirtualMachine", None) is None: + raise Exception(_("There is no VM registered")) + if vm_ref not in _db_content.get("VirtualMachine"): + raise Exception(_("Virtual Machine with ref %s is not there") %\ + vm_ref) + return _db_content.get("VirtualMachine")[vm_ref] + + +class FakeFactory(object): + """ Fake factory class for the suds client """ + + def __init__(self): + pass + + def create(self, obj_name): + """ Creates a namespace object """ + return DataObject() + + +class FakeVim(object): + """Fake VIM Class""" + + def __init__(self, protocol="https", host="localhost", trace=None): + """ Initializes the suds client object, sets the service content + contents and the cookies for the session """ + self._session = None + self.client = DataObject() + self.client.factory = FakeFactory() + + transport = DataObject() + transport.cookiejar = "Fake-CookieJar" + options = DataObject() + options.transport = transport + + self.client.options = options + + service_content = self.client.factory.create('ns0:ServiceContent') + service_content.propertyCollector = "PropCollector" + service_content.virtualDiskManager = "VirtualDiskManager" + service_content.fileManager = "FileManager" + service_content.rootFolder = "RootFolder" + service_content.sessionManager = "SessionManager" + self._service_content = service_content + + def get_service_content(self): + return self._service_content + + def __repr__(self): + return "Fake VIM Object" + + def __str__(self): + return "Fake VIM Object" + + def _login(self): + """ Logs in and sets the session object in the db """ + self._session = str(uuid.uuid4()) + session = DataObject() + session.key = self._session + _db_content['session'][self._session] = session + return session + + def _logout(self): + """ Logs out and remove the session object ref from the db """ + s = self._session + self._session = None + if s not in _db_content['session']: + raise exception.Error( + _("Logging out a session that is invalid or already logged " + "out: %s") % s) + del _db_content['session'][s] + + def _terminate(self, *args, **kwargs): + """ Terminates a session """ + s = kwargs.get("sessionId")[0] + if s not in _db_content['session']: + return + del _db_content['session'][s] + + def _check_session(self): + """ Checks if the session is active """ + if (self._session is None or self._session not in + _db_content['session']): + LOG.debug(_("Session is faulty")) + raise SessionFaultyException(_("Session Invalid")) + + def _create_vm(self, method, *args, **kwargs): + """ Creates and registers a VM object with the Host System """ + config_spec = kwargs.get("config") + ds = _db_content["Datastore"][_db_content["Datastore"].keys()[0]] + vm_dict = {"name": config_spec.name, + "ds": ds, + "powerstate": "poweredOff", + "vmPathName": config_spec.files.vmPathName, + "numCpu": config_spec.numCPUs, + "mem": config_spec.memoryMB} + virtual_machine = VirtualMachine(**vm_dict) + _create_object("VirtualMachine", virtual_machine) + task_mdo = create_task(method, "success") + return task_mdo.obj + + def _reconfig_vm(self, method, *args, **kwargs): + """ Reconfigures a VM and sets the properties supplied """ + vm_ref = args[0] + vm_mdo = _get_vm_mdo(vm_ref) + vm_mdo.reconfig(self.client.factory, kwargs.get("spec")) + task_mdo = create_task(method, "success") + return task_mdo.obj + + def _create_copy_disk(self, method, vmdk_file_path): + """ Creates/copies a vmdk file object in the datastore """ + # We need to add/create both .vmdk and .-flat.vmdk files + flat_vmdk_file_path = \ + vmdk_file_path.replace(".vmdk", "-flat.vmdk") + _add_file(vmdk_file_path) + _add_file(flat_vmdk_file_path) + task_mdo = create_task(method, "success") + return task_mdo.obj + + def _snapshot_vm(self, method): + """ Snapshots a VM. Here we do nothing for faking sake """ + task_mdo = create_task(method, "success") + return task_mdo.obj + + def _delete_disk(self, method, *args, **kwargs): + """ Deletes .vmdk and -flat.vmdk files corresponding to the VM """ + vmdk_file_path = kwargs.get("name") + flat_vmdk_file_path = \ + vmdk_file_path.replace(".vmdk", "-flat.vmdk") + _remove_file(vmdk_file_path) + _remove_file(flat_vmdk_file_path) + task_mdo = create_task(method, "success") + return task_mdo.obj + + def _delete_file(self, method, *args, **kwargs): + """ Deletes a file from the datastore """ + _remove_file(kwargs.get("name")) + task_mdo = create_task(method, "success") + return task_mdo.obj + + def _just_return(self): + """ Fakes a return """ + return + + def _unregister_vm(self, method, *args, **kwargs): + """ Unregisters a VM from the Host System """ + vm_ref = args[0] + _get_vm_mdo(vm_ref) + del _db_content["VirtualMachine"][vm_ref] + + def _search_ds(self, method, *args, **kwargs): + """ Searches the datastore for a file """ + ds_path = kwargs.get("datastorePath") + if _db_content.get("files", None) is None: + raise Exception(_("No files have been added yet")) + for file in _db_content.get("files"): + if file.find(ds_path) != -1: + task_mdo = create_task(method, "success") + return task_mdo.obj + task_mdo = create_task(method, "error") + return task_mdo.obj + + def _make_dir(self, method, *args, **kwargs): + """ Creates a directory in the datastore """ + ds_path = kwargs.get("name") + if _db_content.get("files", None) is None: + raise Exception(_("No files have been added yet")) + _db_content["files"].append(ds_path) + + def _set_power_state(self, method, vm_ref, pwr_state="poweredOn"): + """ Sets power state for the VM """ + if _db_content.get("VirtualMachine", None) is None: + raise Exception(_(" No Virtual Machine has been registered yet")) + if vm_ref not in _db_content.get("VirtualMachine"): + raise Exception(_("Virtual Machine with ref %s is not there") %\ + vm_ref) + vm_mdo = _db_content.get("VirtualMachine").get(vm_ref) + vm_mdo.set("runtime.powerState", pwr_state) + task_mdo = create_task(method, "success") + return task_mdo.obj + + def _retrieve_properties(self, method, *args, **kwargs): + """ Retrieves properties based on the type """ + spec_set = kwargs.get("specSet")[0] + type = spec_set.propSet[0].type + properties = spec_set.propSet[0].pathSet + objs = spec_set.objectSet + lst_ret_objs = [] + for obj in objs: + try: + obj_ref = obj.obj + #This means that we are doing a search for the managed + #dataobects of the type in the inventory + if obj_ref == "RootFolder": + for mdo_ref in _db_content[type]: + mdo = _db_content[type][mdo_ref] + #Create a temp Managed object which has the same ref + #as the parent object and copies just the properties + #asked for. We need .obj along with the propSet of + #just the properties asked for + temp_mdo = ManagedObject(mdo.objName, mdo.obj) + for prop in properties: + temp_mdo.set(prop, mdo.get(prop)) + lst_ret_objs.append(temp_mdo) + else: + if obj_ref in _db_content[type]: + mdo = _db_content[type][obj_ref] + temp_mdo = ManagedObject(mdo.objName, obj_ref) + for prop in properties: + temp_mdo.set(prop, mdo.get(prop)) + lst_ret_objs.append(temp_mdo) + except Exception: + continue + return lst_ret_objs + + def _add_port_group(self, method, *args, **kwargs): + """ Adds a port group to the host system """ + host_mdo = \ + _db_content["HostSystem"][_db_content["HostSystem"].keys()[0]] + host_mdo._add_port_group(kwargs.get("portgrp")) + + def __getattr__(self, attr_name): + if attr_name != "Login": + self._check_session() + if attr_name == "Login": + return lambda *args, **kwargs: self._login() + elif attr_name == "Logout": + self._logout() + elif attr_name == "Terminate": + return lambda *args, **kwargs: self._terminate(*args, **kwargs) + elif attr_name == "CreateVM_Task": + return lambda *args, **kwargs: self._create_vm(attr_name, + *args, **kwargs) + elif attr_name == "ReconfigVM_Task": + return lambda *args, **kwargs: self._reconfig_vm(attr_name, + *args, **kwargs) + elif attr_name == "CreateVirtualDisk_Task": + return lambda *args, **kwargs: self._create_copy_disk(attr_name, + kwargs.get("name")) + elif attr_name == "DeleteDatastoreFile_Task": + return lambda *args, **kwargs: self._delete_file(attr_name, + *args, **kwargs) + elif attr_name == "PowerOnVM_Task": + return lambda *args, **kwargs: self._set_power_state(attr_name, + args[0], "poweredOn") + elif attr_name == "PowerOffVM_Task": + return lambda *args, **kwargs: self._set_power_state(attr_name, + args[0], "poweredOff") + elif attr_name == "RebootGuest": + return lambda *args, **kwargs: self._just_return() + elif attr_name == "ResetVM_Task": + return lambda *args, **kwargs: self._set_power_state(attr_name, + args[0], "poweredOn") + elif attr_name == "SuspendVM_Task": + return lambda *args, **kwargs: self._set_power_state(attr_name, + args[0], "suspended") + elif attr_name == "CreateSnapshot_Task": + return lambda *args, **kwargs: self._snapshot_vm(attr_name) + elif attr_name == "CopyVirtualDisk_Task": + return lambda *args, **kwargs: self._create_copy_disk(attr_name, + kwargs.get("destName")) + elif attr_name == "DeleteVirtualDisk_Task": + return lambda *args, **kwargs: self._delete_disk(attr_name, + *args, **kwargs) + elif attr_name == "UnregisterVM": + return lambda *args, **kwargs: self._unregister_vm(attr_name, + *args, **kwargs) + elif attr_name == "SearchDatastore_Task": + return lambda *args, **kwargs: self._search_ds(attr_name, + *args, **kwargs) + elif attr_name == "MakeDirectory": + return lambda *args, **kwargs: self._make_dir(attr_name, + *args, **kwargs) + elif attr_name == "RetrieveProperties": + return lambda *args, **kwargs: self._retrieve_properties( + attr_name, *args, **kwargs) + elif attr_name == "AcquireCloneTicket": + return lambda *args, **kwargs: self._just_return() + elif attr_name == "AddPortGroup": + return lambda *args, **kwargs: self._add_port_group(attr_name, + *args, **kwargs) diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py index b9645e220..edec3eb34 100644 --- a/nova/virt/vmwareapi/io_util.py +++ b/nova/virt/vmwareapi/io_util.py @@ -16,13 +16,8 @@ # under the License. """ -Helper classes for multi-threaded I/O (read/write) in the basis of chunks. - -The class ThreadSafePipe queues the chunk data. - -The class IOThread reads chunks from input file and pipes it to output file -till it reaches the transferable size - +Reads a chunk from input file and writes the same to the output file till +it reaches the transferable size """ from Queue import Empty @@ -32,27 +27,26 @@ from threading import Thread import time import traceback -THREAD_SLEEP_TIME = .01 +THREAD_SLEEP_TIME = 0.01 class ThreadSafePipe(Queue): - """ThreadSafePipe class queue's the chunk data.""" + """ThreadSafePipe class queues the chunk data""" def __init__(self, max_size=None): - """Initializes the queue""" Queue.__init__(self, max_size) self.eof = False def write(self, data): - """Writes the chunk data to the queue.""" + """Writes the chunk data to the queue""" self.put(data, block=False) def read(self): - """Retrieves the chunk data from the queue.""" + """Retrieves the chunk data from the queue""" return self.get(block=False) def set_eof(self, eof): - """Sets EOF to mark reading of input file finishes.""" + """Sets EOF to mark reading of input file finishes""" self.eof = eof def get_eof(self): @@ -61,16 +55,11 @@ class ThreadSafePipe(Queue): class IOThread(Thread): - """ - IOThread reads chunks from input file and pipes it to output file till it - reaches the transferable size + """IOThread reads chunks from input file and pipes it to output file till + it reaches the transferable size """ def __init__(self, input_file, output_file, chunk_size, transfer_size): - """ - Initialize the thread. - inputFile and outputFile should be file like objects. - """ Thread.__init__(self) self.input_file = input_file self.output_file = output_file @@ -83,9 +72,8 @@ class IOThread(Thread): self._exception = None def run(self): - """ - Pipes the input chunk read to the output file till it reaches - transferable size + """Pipes the input chunk read to the output file till it reaches + a transferable size """ try: if self.transfer_size and self.transfer_size <= self.chunk_size: @@ -131,10 +119,10 @@ class IOThread(Thread): if not self.transfer_size is None: if self.read_size < self.transfer_size: - raise IOError(_("Not enough data (%(read_size)d of " - "%(transfer_size)d bytes)") % - {'read_size': self.read_size, - 'transfer_size': self.transfer_size}) + raise IOError(_("Not enough data (%(read_size)d " + "of %(transfer_size)d bytes)") \ + % ({'read_size': self.read_size, + 'transfer_size': self.transfer_size})) except Exception: self._error = True @@ -142,18 +130,20 @@ class IOThread(Thread): self._done = True def stop_io_transfer(self): - """Set stop flag to true, which causes the thread to stop safely.""" + """Set the stop flag to true, which causes the thread to stop + safely + """ self._stop_transfer = True self.join() def get_error(self): - """Returns the error string.""" + """Returns the error string""" return self._error def get_exception(self): - """Returns the traceback exception string.""" + """Returns the traceback exception string""" return self._exception def is_done(self): - """Checks whether transfer is complete.""" + """Checks whether transfer is complete""" return self._done diff --git a/nova/virt/vmwareapi/network_utils.py b/nova/virt/vmwareapi/network_utils.py new file mode 100644 index 000000000..6927b15ca --- /dev/null +++ b/nova/virt/vmwareapi/network_utils.py @@ -0,0 +1,117 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Utility functions for ESX Networking +""" + +from nova import log as logging +from nova.virt.vmwareapi import vim_util +from nova.virt.vmwareapi import vm_util +from nova.virt.vmwareapi.vim import VimException + +LOG = logging.getLogger("nova.virt.vmwareapi.network_utils") + +PORT_GROUP_EXISTS_EXCEPTION = \ + 'The specified key, name, or identifier already exists.' + + +class NetworkHelper: + + @classmethod + def get_network_with_the_name(cls, session, network_name="vmnet0"): + """ Gets reference to the network whose name is passed as the + argument. """ + datacenters = session._call_method(vim_util, "get_objects", + "Datacenter", ["network"]) + vm_networks = datacenters[0].propSet[0].val.ManagedObjectReference + networks = session._call_method(vim_util, + "get_properites_for_a_collection_of_objects", + "Network", vm_networks, ["summary.name"]) + for network in networks: + if network.propSet[0].val == network_name: + return network.obj + return None + + @classmethod + def get_vswitches_for_vlan_interface(cls, session, vlan_interface): + """ Gets the list of vswitches associated with the physical + network adapter with the name supplied""" + #Get the list of vSwicthes on the Host System + host_mor = session._call_method(vim_util, "get_objects", + "HostSystem")[0].obj + vswitches = session._call_method(vim_util, + "get_dynamic_property", host_mor, + "HostSystem", "config.network.vswitch").HostVirtualSwitch + vswicthes_conn_to_physical_nic = [] + #For each vSwitch check if it is associated with the network adapter + for elem in vswitches: + try: + for nic_elem in elem.pnic: + if str(nic_elem).split('-')[-1].find(vlan_interface) != -1: + vswicthes_conn_to_physical_nic.append(elem.name) + except Exception: + pass + return vswicthes_conn_to_physical_nic + + @classmethod + def check_if_vlan_id_is_proper(cls, session, pg_name, vlan_id): + """ Check if the vlan id associated with the port group matches the + vlan tag supplied """ + host_mor = session._call_method(vim_util, "get_objects", + "HostSystem")[0].obj + port_grps_on_host = session._call_method(vim_util, + "get_dynamic_property", host_mor, + "HostSystem", "config.network.portgroup").HostPortGroup + for p_gp in port_grps_on_host: + if p_gp.spec.name == pg_name: + if p_gp.spec.vlanId == vlan_id: + return True, vlan_id + else: + return False, p_gp.spec.vlanId + + @classmethod + def create_port_group(cls, session, pg_name, vswitch_name, vlan_id=0): + """ Creates a port group on the host system with the vlan tags + supplied. VLAN id 0 means no vlan id association """ + client_factory = session._get_vim().client.factory + add_prt_grp_spec = vm_util.get_add_vswitch_port_group_spec( + client_factory, + vswitch_name, + pg_name, + vlan_id) + host_mor = session._call_method(vim_util, "get_objects", + "HostSystem")[0].obj + network_system_mor = session._call_method(vim_util, + "get_dynamic_property", host_mor, + "HostSystem", "configManager.networkSystem") + LOG.debug(_("Creating Port Group with name %s on " + "the ESX host") % pg_name) + try: + session._call_method(session._get_vim(), + "AddPortGroup", network_system_mor, + portgrp=add_prt_grp_spec) + except VimException, exc: + #There can be a race condition when two instances try + #adding port groups at the same time. One succeeds, then + #the other one will get an exception. Since we are + #concerned with the port group being created, which is done + #by the other call, we can ignore the exception. + if str(exc).find(PORT_GROUP_EXISTS_EXCEPTION) == -1: + raise Exception(exc) + LOG.debug(_("Created Port Group with name %s on " + "the ESX host") % pg_name) diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py index 45214be04..37f80c133 100644 --- a/nova/virt/vmwareapi/read_write_util.py +++ b/nova/virt/vmwareapi/read_write_util.py @@ -20,20 +20,15 @@ Collection of classes to handle image upload/download to/from Image service (like Glance image storage and retrieval service) from/to ESX/ESXi server. -Also a class is available that acts as Fake image service. It uses local -file system for storage. - """ import httplib -import json -import logging -import os import urllib import urllib2 import urlparse from nova import flags +from nova import log as logging from nova import utils from nova.auth.manager import AuthManager @@ -47,10 +42,9 @@ LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util") class ImageServiceFile: - """The base image service Class""" + """The base image service class""" def __init__(self, file_handle): - """Initialize the file handle.""" self.eof = False self.file_handle = file_handle @@ -67,15 +61,15 @@ class ImageServiceFile: raise NotImplementedError def set_eof(self, eof): - """Set the end of file marker.""" + """Set the end of file marker""" self.eof = eof def get_eof(self): - """Check if the file end has been reached or not.""" + """Check if the file end has been reached or not""" return self.eof def close(self): - """Close the file handle.""" + """Close the file handle""" try: self.file_handle.close() except Exception: @@ -86,16 +80,15 @@ class ImageServiceFile: raise NotImplementedError def __del__(self): - """Destructor. Close the file handle if the same has been forgotten.""" + """Close the file handle on garbage collection""" self.close() class GlanceHTTPWriteFile(ImageServiceFile): - """Glance file write handler Class""" + """Glance file write handler class""" def __init__(self, host, port, image_id, file_size, os_type, adapter_type, version=1, scheme="http"): - """Initialize with the glance host specifics.""" base_url = "%s://%s:%s/images/%s" % (scheme, host, port, image_id) (scheme, netloc, path, params, query, fragment) = \ urlparse.urlparse(base_url) @@ -126,10 +119,9 @@ class GlanceHTTPWriteFile(ImageServiceFile): class GlanceHTTPReadFile(ImageServiceFile): - """Glance file read handler Class""" + """Glance file read handler class""" def __init__(self, host, port, image_id, scheme="http"): - """Initialize with the glance host specifics.""" base_url = "%s://%s:%s/images/%s" % (scheme, host, port, urllib.pathname2url(image_id)) headers = {'User-Agent': USER_AGENT} @@ -138,15 +130,17 @@ class GlanceHTTPReadFile(ImageServiceFile): ImageServiceFile.__init__(self, conn) def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data.""" + """Read a chunk of data""" return self.file_handle.read(chunk_size) def get_size(self): - """Get the size of the file to be read.""" + """Get the size of the file to be read""" return self.file_handle.headers.get("X-Image-Meta-Size", -1) def get_image_properties(self): - """Get the image properties like say OS Type and the Adapter Type""" + """Get the image properties like say OS Type and the + Adapter Type + """ return {"vmware_ostype": self.file_handle.headers.get( "X-Image-Meta-Property-Vmware_ostype"), @@ -158,95 +152,58 @@ class GlanceHTTPReadFile(ImageServiceFile): "X-Image-Meta-Property-Vmware_image_version")} -class FakeFileRead(ImageServiceFile): - """Local file read handler class""" - - def __init__(self, path): - """Initialize the file path""" - self.path = path - file_handle = open(path, "rb") - ImageServiceFile.__init__(self, file_handle) - - def get_size(self): - """Get size of the file to be read""" - return os.path.getsize(os.path.abspath(self.path)) - - def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data""" - return self.file_handle.read(chunk_size) - - def get_image_properties(self): - """Get the image properties like say OS Type and the Adapter Type""" - return {"vmware_ostype": "otherGuest", - "vmware_adaptertype": "lsiLogic", - "vmware_image_version": "1"} - - -class FakeFileWrite(ImageServiceFile): - """Local file write handler Class""" - - def __init__(self, path): - """Initialize the file path.""" - file_handle = open(path, "wb") - ImageServiceFile.__init__(self, file_handle) - - def write(self, data): - """Write data to the file.""" - self.file_handle.write(data) - - class VMwareHTTPFile(object): - """Base Class for HTTP file.""" + """Base class for HTTP file""" def __init__(self, file_handle): - """Intialize the file handle.""" self.eof = False self.file_handle = file_handle def set_eof(self, eof): - """Set the end of file marker.""" + """Set the end of file marker""" self.eof = eof def get_eof(self): - """Check if the end of file has been reached.""" + """Check if the end of file has been reached""" return self.eof def close(self): - """Close the file handle.""" + """Close the file handle""" try: self.file_handle.close() except Exception: pass def __del__(self): - """Destructor. Close the file handle if the same has been forgotten.""" + """Close the file handle on garbage collection""" self.close() def _build_vim_cookie_headers(self, vim_cookies): - """Build ESX host session cookie headers.""" - cookie = str(vim_cookies).split(":")[1].strip() - cookie = cookie[:cookie.find(';')] - return cookie + """Build ESX host session cookie headers""" + cookie_header = "" + for vim_cookie in vim_cookies: + cookie_header = vim_cookie.name + "=" + vim_cookie.value + break + return cookie_header def write(self, data): - """Write data to the file.""" + """Write data to the file""" raise NotImplementedError def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data.""" + """Read a chunk of data""" raise NotImplementedError def get_size(self): - """Get size of the file to be read.""" + """Get size of the file to be read""" raise NotImplementedError class VMWareHTTPWriteFile(VMwareHTTPFile): - """VMWare file write handler Class""" + """VMWare file write handler class""" def __init__(self, host, data_center_name, datastore_name, cookies, file_path, file_size, scheme="https"): - """Initialize the file specifics.""" base_url = "%s://%s/folder/%s" % (scheme, host, file_path) param_list = {"dcPath": data_center_name, "dsName": datastore_name} base_url = base_url + "?" + urllib.urlencode(param_list) @@ -265,7 +222,7 @@ class VMWareHTTPWriteFile(VMwareHTTPFile): VMwareHTTPFile.__init__(self, conn) def write(self, data): - """Write to the file.""" + """Write to the file""" self.file_handle.send(data) def close(self): @@ -273,17 +230,16 @@ class VMWareHTTPWriteFile(VMwareHTTPFile): try: self.conn.getresponse() except Exception, excep: - LOG.debug(_("Exception during close of connection in " + LOG.debug(_("Exception during HTTP connection close in " "VMWareHTTpWrite. Exception is %s") % excep) super(VMWareHTTPWriteFile, self).close() class VmWareHTTPReadFile(VMwareHTTPFile): - """VMWare file read handler Class""" + """VMWare file read handler class""" def __init__(self, host, data_center_name, datastore_name, cookies, file_path, scheme="https"): - """Initialize the file specifics.""" base_url = "%s://%s/folder/%s" % (scheme, host, urllib.pathname2url(file_path)) param_list = {"dcPath": data_center_name, "dsName": datastore_name} @@ -295,9 +251,9 @@ class VmWareHTTPReadFile(VMwareHTTPFile): VMwareHTTPFile.__init__(self, conn) def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data.""" + """Read a chunk of data""" return self.file_handle.read(chunk_size) def get_size(self): - """Get size of the file to be read.""" + """Get size of the file to be read""" return self.file_handle.headers.get("Content-Length", -1) diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index 9aca1b7ae..6a3e4b376 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -16,32 +16,39 @@ # under the License. """ -Class facilitating SOAP calls to ESX/ESXi server - +Classes for making VMware VI SOAP calls """ import httplib -import ZSI +from suds.client import Client +from suds.plugin import MessagePlugin +from suds.sudsobject import Property -from nova.virt.vmwareapi import VimService_services +from nova import flags RESP_NOT_XML_ERROR = 'Response is "text/html", not "text/xml' CONN_ABORT_ERROR = 'Software caused connection abort' ADDRESS_IN_USE_ERROR = 'Address already in use' +FLAGS = flags.FLAGS +flags.DEFINE_string('vmwareapi_wsdl_loc', + None, + 'VIM Service WSDL Location' + 'E.g http:///vimService.wsdl' + 'Due to a bug in vSphere ESX 4.1 default wsdl' + 'Read the readme for vmware to setup') + class VimException(Exception): """The VIM Exception class""" def __init__(self, exception_summary, excep): - """Initializer""" Exception.__init__(self) self.exception_summary = exception_summary self.exception_obj = excep def __str__(self): - """The informal string representation of the object""" return self.exception_summary + str(self.exception_obj) @@ -56,38 +63,53 @@ class SessionFaultyException(VimException): class VimAttributeError(VimException): - """Attribute Error""" + """VI Attribute Error""" pass +class VIMMessagePlugin(MessagePlugin): + + def addAttributeForValue(self, node): + #suds does not handle AnyType properly + #VI SDK requires type attribute to be set when AnyType is used + if node.name == 'value': + node.set('xsi:type', 'xsd:string') + + def marshalled(self, context): + """Suds will send the specified soap envelope. + Provides the plugin with the opportunity to prune empty + nodes and fixup nodes before sending it to the server + """ + #suds builds the entire request object based on the wsdl schema + #VI SDK throws server errors if optional SOAP nodes are sent without + #values. E.g as opposed to test + context.envelope.prune() + context.envelope.walk(self.addAttributeForValue) + + class Vim: """The VIM Object""" def __init__(self, protocol="https", - host="localhost", - trace=None): + host="localhost"): """ - Initializer - protocol: http or https host : ESX IPAddress[:port] or ESX Hostname[:port] - trace : File handle (eg. sys.stdout, sys.stderr , - open("file.txt",w), Use it only for debugging - SOAP Communication Creates the necessary Communication interfaces, Gets the ServiceContent for initiating SOAP transactions """ self._protocol = protocol self._host_name = host - service_locator = VimService_services.VimServiceLocator() - connect_string = "%s://%s/sdk" % (self._protocol, self._host_name) - if trace == None: - self.proxy = \ - service_locator.getVimPortType(url=connect_string) - else: - self.proxy = service_locator.getVimPortType(url=connect_string, - tracefile=trace) + wsdl_url = FLAGS.vmwareapi_wsdl_loc + if wsdl_url is None: + raise Exception(_("Must specify vmwareapi_wsdl_loc")) + #Use this when VMware fixes their faulty wsdl + #wsdl_url = '%s://%s/sdk/vimService.wsdl' % (self._protocol, + # self._host_name) + url = '%s://%s/sdk' % (self._protocol, self._host_name) + self.client = Client(wsdl_url, location=url, + plugins=[VIMMessagePlugin()]) self._service_content = \ self.RetrieveServiceContent("ServiceInstance") @@ -102,45 +124,29 @@ class Vim: except AttributeError: def vim_request_handler(managed_object, **kwargs): - """ - managed_object : Managed Object Reference or Managed + """managed_object : Managed Object Reference or Managed Object Name **kw : Keyword arguments of the call """ #Dynamic handler for VI SDK Calls - response = None try: - request_msg = \ - self._request_message_builder(attr_name, - managed_object, **kwargs) - request = getattr(self.proxy, attr_name) - response = request(request_msg) - if response == None: - return None - else: - try: - return getattr(response, "_returnval") - except AttributeError, excep: - return None + request_mo = \ + self._request_managed_object_builder(managed_object) + request = getattr(self.client.service, attr_name) + return request(request_mo, **kwargs) except AttributeError, excep: raise VimAttributeError(_("No such SOAP method '%s'" " provided by VI SDK") % (attr_name), excep) - except ZSI.FaultException, excep: - raise SessionFaultyException(_(" in" - " %s:") % (attr_name), excep) - except ZSI.EvaluateException, excep: - raise SessionFaultyException(_(" in" - " %s:") % (attr_name), excep) except (httplib.CannotSendRequest, httplib.ResponseNotReady, httplib.CannotSendHeader), excep: - raise SessionOverLoadException(_("httplib errror in" + raise SessionOverLoadException(_("httplib error in" " %s: ") % (attr_name), excep) except Exception, excep: # Socket errors which need special handling for they # might be caused by ESX API call overload if (str(excep).find(ADDRESS_IN_USE_ERROR) != -1 or - str(excep).find(CONN_ABORT_ERROR)): + str(excep).find(CONN_ABORT_ERROR)) != -1: raise SessionOverLoadException(_("Socket error in" " %s: ") % (attr_name), excep) # Type error that needs special handling for it might be @@ -153,25 +159,18 @@ class Vim: _("Exception in %s ") % (attr_name), excep) return vim_request_handler - def _request_message_builder(self, method_name, managed_object, **kwargs): - """Builds the Request Message""" - #Request Message Builder - request_msg = getattr(VimService_services, \ - method_name + "RequestMsg")() - element = request_msg.new__this(managed_object) + def _request_managed_object_builder(self, managed_object): + """Builds the request managed object""" + #Request Managed Object Builder if type(managed_object) == type(""): - element.set_attribute_type(managed_object) + mo = Property(managed_object) + mo._type = managed_object else: - element.set_attribute_type(managed_object.get_attribute_type()) - request_msg.set_element__this(element) - for key in kwargs: - getattr(request_msg, "set_element_" + key)(kwargs[key]) - return request_msg + mo = managed_object + return mo def __repr__(self): - """The official string representation""" return "VIM Object" def __str__(self): - """The informal string representation""" return "VIM Object" diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py index d07f7c278..619ad3c0b 100644 --- a/nova/virt/vmwareapi/vim_util.py +++ b/nova/virt/vmwareapi/vim_util.py @@ -17,178 +17,163 @@ """ The VMware API utility module - """ -from nova.virt.vmwareapi.VimService_services_types import ns0 - -MAX_CLONE_RETRIES = 1 - -def build_recursive_traversal_spec(): +def build_recursive_traversal_spec(client_factory): """Builds the Traversal Spec""" #Traversal through "hostFolder" branch - visit_folders_select_spec = ns0.SelectionSpec_Def("visitFolders").pyclass() - visit_folders_select_spec.set_element_name("visitFolders") - select_set = [visit_folders_select_spec] - dc_to_hf = ns0.TraversalSpec_Def("dc_to_hf").pyclass() - dc_to_hf.set_element_name("dc_to_hf") - dc_to_hf.set_element_type("Datacenter") - dc_to_hf.set_element_path("hostFolder") - dc_to_hf.set_element_skip(False) - dc_to_hf.set_element_selectSet(select_set) + visit_folders_select_spec = client_factory.create('ns0:SelectionSpec') + visit_folders_select_spec.name = "visitFolders" + dc_to_hf = client_factory.create('ns0:TraversalSpec') + dc_to_hf.name = "dc_to_hf" + dc_to_hf.type = "Datacenter" + dc_to_hf.path = "hostFolder" + dc_to_hf.skip = False + dc_to_hf.selectSet = [visit_folders_select_spec] #Traversal through "vmFolder" branch - visit_folders_select_spec = ns0.SelectionSpec_Def("visitFolders").pyclass() - visit_folders_select_spec.set_element_name("visitFolders") - select_set = [visit_folders_select_spec] - dc_to_vmf = ns0.TraversalSpec_Def("dc_to_vmf").pyclass() - dc_to_vmf.set_element_name("dc_to_vmf") - dc_to_vmf.set_element_type("Datacenter") - dc_to_vmf.set_element_path("vmFolder") - dc_to_vmf.set_element_skip(False) - dc_to_vmf.set_element_selectSet(select_set) + visit_folders_select_spec = client_factory.create('ns0:SelectionSpec') + visit_folders_select_spec.name = "visitFolders" + dc_to_vmf = client_factory.create('ns0:TraversalSpec') + dc_to_vmf.name = "dc_to_vmf" + dc_to_vmf.type = "Datacenter" + dc_to_vmf.path = "vmFolder" + dc_to_vmf.skip = False + dc_to_vmf.selectSet = [visit_folders_select_spec] #Traversal to the DataStore from the DataCenter visit_folders_select_spec = \ - ns0.SelectionSpec_Def("traverseChild").pyclass() - visit_folders_select_spec.set_element_name("traverseChild") - select_set = [visit_folders_select_spec] - dc_to_ds = ns0.TraversalSpec_Def("dc_to_ds").pyclass() - dc_to_ds.set_element_name("dc_to_ds") - dc_to_ds.set_element_type("Datacenter") - dc_to_ds.set_element_path("datastore") - dc_to_ds.set_element_skip(False) - dc_to_ds.set_element_selectSet(select_set) + client_factory.create('ns0:SelectionSpec') + visit_folders_select_spec.name = "traverseChild" + dc_to_ds = client_factory.create('ns0:TraversalSpec') + dc_to_ds.name = "dc_to_ds" + dc_to_ds.type = "Datacenter" + dc_to_ds.path = "datastore" + dc_to_ds.skip = False + dc_to_ds.selectSet = [visit_folders_select_spec] #Traversal through "vm" branch visit_folders_select_spec = \ - ns0.SelectionSpec_Def("visitFolders").pyclass() - visit_folders_select_spec.set_element_name("visitFolders") - select_set = [visit_folders_select_spec] - h_to_vm = ns0.TraversalSpec_Def("h_to_vm").pyclass() - h_to_vm.set_element_name("h_to_vm") - h_to_vm.set_element_type("HostSystem") - h_to_vm.set_element_path("vm") - h_to_vm.set_element_skip(False) - h_to_vm.set_element_selectSet(select_set) + client_factory.create('ns0:SelectionSpec') + visit_folders_select_spec.name = "visitFolders" + h_to_vm = client_factory.create('ns0:TraversalSpec') + h_to_vm.name = "h_to_vm" + h_to_vm.type = "HostSystem" + h_to_vm.path = "vm" + h_to_vm.skip = False + h_to_vm.selectSet = [visit_folders_select_spec] #Traversal through "host" branch - cr_to_h = ns0.TraversalSpec_Def("cr_to_h").pyclass() - cr_to_h.set_element_name("cr_to_h") - cr_to_h.set_element_type("ComputeResource") - cr_to_h.set_element_path("host") - cr_to_h.set_element_skip(False) - cr_to_h.set_element_selectSet([]) - - cr_to_ds = ns0.TraversalSpec_Def("cr_to_ds").pyclass() - cr_to_ds.set_element_name("cr_to_ds") - cr_to_ds.set_element_type("ComputeResource") - cr_to_ds.set_element_path("datastore") - cr_to_ds.set_element_skip(False) + cr_to_h = client_factory.create('ns0:TraversalSpec') + cr_to_h.name = "cr_to_h" + cr_to_h.type = "ComputeResource" + cr_to_h.path = "host" + cr_to_h.skip = False + cr_to_h.selectSet = [] + + cr_to_ds = client_factory.create('ns0:TraversalSpec') + cr_to_ds.name = "cr_to_ds" + cr_to_ds.type = "ComputeResource" + cr_to_ds.path = "datastore" + cr_to_ds.skip = False #Traversal through "resourcePool" branch - rp_to_rp_select_spec = ns0.SelectionSpec_Def("rp_to_rp").pyclass() - rp_to_rp_select_spec.set_element_name("rp_to_rp") - rp_to_vm_select_spec = ns0.SelectionSpec_Def("rp_to_vm").pyclass() - rp_to_vm_select_spec.set_element_name("rp_to_vm") - select_set = [rp_to_rp_select_spec, rp_to_vm_select_spec] - cr_to_rp = ns0.TraversalSpec_Def("cr_to_rp").pyclass() - cr_to_rp.set_element_name("cr_to_rp") - cr_to_rp.set_element_type("ComputeResource") - cr_to_rp.set_element_path("resourcePool") - cr_to_rp.set_element_skip(False) - cr_to_rp.set_element_selectSet(select_set) + rp_to_rp_select_spec = client_factory.create('ns0:SelectionSpec') + rp_to_rp_select_spec.name = "rp_to_rp" + rp_to_vm_select_spec = client_factory.create('ns0:SelectionSpec') + rp_to_vm_select_spec.name = "rp_to_vm" + cr_to_rp = client_factory.create('ns0:TraversalSpec') + cr_to_rp.name = "cr_to_rp" + cr_to_rp.type = "ComputeResource" + cr_to_rp.path = "resourcePool" + cr_to_rp.skip = False + cr_to_rp.selectSet = [rp_to_rp_select_spec, rp_to_vm_select_spec] #Traversal through all ResourcePools - rp_to_rp_select_spec = ns0.SelectionSpec_Def("rp_to_rp").pyclass() - rp_to_rp_select_spec.set_element_name("rp_to_rp") - rp_to_vm_select_spec = ns0.SelectionSpec_Def("rp_to_vm").pyclass() - rp_to_vm_select_spec.set_element_name("rp_to_vm") - select_set = [rp_to_rp_select_spec, rp_to_vm_select_spec] - rp_to_rp = ns0.TraversalSpec_Def("rp_to_rp").pyclass() - rp_to_rp.set_element_name("rp_to_rp") - rp_to_rp.set_element_type("ResourcePool") - rp_to_rp.set_element_path("resourcePool") - rp_to_rp.set_element_skip(False) - rp_to_rp.set_element_selectSet(select_set) + rp_to_rp_select_spec = client_factory.create('ns0:SelectionSpec') + rp_to_rp_select_spec.name = "rp_to_rp" + rp_to_vm_select_spec = client_factory.create('ns0:SelectionSpec') + rp_to_vm_select_spec.name = "rp_to_vm" + rp_to_rp = client_factory.create('ns0:TraversalSpec') + rp_to_rp.name = "rp_to_rp" + rp_to_rp.type = "ResourcePool" + rp_to_rp.path = "resourcePool" + rp_to_rp.skip = False + rp_to_rp.selectSet = [rp_to_rp_select_spec, rp_to_vm_select_spec] #Traversal through ResourcePools vm folders - rp_to_rp_select_spec = ns0.SelectionSpec_Def("rp_to_rp").pyclass() - rp_to_rp_select_spec.set_element_name("rp_to_rp") - rp_to_vm_select_spec = ns0.SelectionSpec_Def("rp_to_vm").pyclass() - rp_to_vm_select_spec.set_element_name("rp_to_vm") - select_set = [rp_to_rp_select_spec, rp_to_vm_select_spec] - rp_to_vm = ns0.TraversalSpec_Def("rp_to_vm").pyclass() - rp_to_vm.set_element_name("rp_to_vm") - rp_to_vm.set_element_type("ResourcePool") - rp_to_vm.set_element_path("vm") - rp_to_vm.set_element_skip(False) - rp_to_vm.set_element_selectSet(select_set) + rp_to_rp_select_spec = client_factory.create('ns0:SelectionSpec') + rp_to_rp_select_spec.name = "rp_to_rp" + rp_to_vm_select_spec = client_factory.create('ns0:SelectionSpec') + rp_to_vm_select_spec.name = "rp_to_vm" + rp_to_vm = client_factory.create('ns0:TraversalSpec') + rp_to_vm.name = "rp_to_vm" + rp_to_vm.type = "ResourcePool" + rp_to_vm.path = "vm" + rp_to_vm.skip = False + rp_to_vm.selectSet = [rp_to_rp_select_spec, rp_to_vm_select_spec] #Include all Traversals and Recurse into them visit_folders_select_spec = \ - ns0.SelectionSpec_Def("visitFolders").pyclass() - visit_folders_select_spec.set_element_name("visitFolders") - select_set = [visit_folders_select_spec, dc_to_hf, dc_to_vmf, + client_factory.create('ns0:SelectionSpec') + visit_folders_select_spec.name = "visitFolders" + traversal_spec = client_factory.create('ns0:TraversalSpec') + traversal_spec.name = "visitFolders" + traversal_spec.type = "Folder" + traversal_spec.path = "childEntity" + traversal_spec.skip = False + traversal_spec.selectSet = [visit_folders_select_spec, dc_to_hf, dc_to_vmf, cr_to_ds, cr_to_h, cr_to_rp, rp_to_rp, h_to_vm, rp_to_vm] - traversal_spec = ns0.TraversalSpec_Def("visitFolders").pyclass() - traversal_spec.set_element_name("visitFolders") - traversal_spec.set_element_type("Folder") - traversal_spec.set_element_path("childEntity") - traversal_spec.set_element_skip(False) - traversal_spec.set_element_selectSet(select_set) return traversal_spec -def build_property_spec(type="VirtualMachine", properties_to_collect=["name"], +def build_property_spec(client_factory, type="VirtualMachine", + properties_to_collect=["name"], all_properties=False): """Builds the Property Spec""" - property_spec = ns0.PropertySpec_Def("propertySpec").pyclass() - property_spec.set_element_type(type) - property_spec.set_element_all(all_properties) - property_spec.set_element_pathSet(properties_to_collect) + property_spec = client_factory.create('ns0:PropertySpec') + property_spec.all = all_properties + property_spec.pathSet = properties_to_collect + property_spec.type = type return property_spec -def build_object_spec(root_folder, traversal_specs): +def build_object_spec(client_factory, root_folder, traversal_specs): """Builds the object Spec""" - object_spec = ns0.ObjectSpec_Def("ObjectSpec").pyclass() - object_spec.set_element_obj(root_folder) - object_spec.set_element_skip(False) - object_spec.set_element_selectSet(traversal_specs) + object_spec = client_factory.create('ns0:ObjectSpec') + object_spec.obj = root_folder + object_spec.skip = False + object_spec.selectSet = traversal_specs return object_spec -def build_property_filter_spec(property_specs, object_specs): +def build_property_filter_spec(client_factory, property_specs, object_specs): """Builds the Property Filter Spec""" - property_filter_spec = \ - ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() - property_filter_spec.set_element_propSet(property_specs) - property_filter_spec.set_element_objectSet(object_specs) + property_filter_spec = client_factory.create('ns0:PropertyFilterSpec') + property_filter_spec.propSet = property_specs + property_filter_spec.objectSet = object_specs return property_filter_spec def get_object_properties(vim, collector, mobj, type, properties): """Gets the properties of the Managed object specified""" + client_factory = vim.client.factory if mobj is None: return None usecoll = collector if usecoll is None: - usecoll = vim.get_service_content().PropertyCollector - property_filter_spec = \ - ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() - property_filter_spec._propSet = \ - [ns0.PropertySpec_Def("PropertySpec").pyclass()] - property_filter_spec.PropSet[0]._all = \ - (properties == None or len(properties) == 0) - property_filter_spec.PropSet[0]._type = type - property_filter_spec.PropSet[0]._pathSet = properties - - property_filter_spec._objectSet = \ - [ns0.ObjectSpec_Def("ObjectSpec").pyclass()] - property_filter_spec.ObjectSet[0]._obj = mobj - property_filter_spec.ObjectSet[0]._skip = False + usecoll = vim.get_service_content().propertyCollector + property_filter_spec = client_factory.create('ns0:PropertyFilterSpec') + property_spec = client_factory.create('ns0:PropertySpec') + property_spec.all = (properties == None or len(properties) == 0) + property_spec.pathSet = properties + property_spec.type = type + object_spec = client_factory.create('ns0:ObjectSpec') + object_spec.obj = mobj + object_spec.skip = False + property_filter_spec.propSet = [property_spec] + property_filter_spec.objectSet = [object_spec] return vim.RetrieveProperties(usecoll, specSet=[property_filter_spec]) @@ -198,74 +183,68 @@ def get_dynamic_property(vim, mobj, type, property_name): get_object_properties(vim, None, mobj, type, [property_name]) property_value = None if obj_content: - dynamic_property = obj_content[0].PropSet + dynamic_property = obj_content[0].propSet if dynamic_property: - property_value = dynamic_property[0].Val + property_value = dynamic_property[0].val return property_value def get_objects(vim, type, properties_to_collect=["name"], all=False): """Gets the list of objects of the type specified""" - object_spec = build_object_spec(vim.get_service_content().RootFolder, - [build_recursive_traversal_spec()]) - property_spec = build_property_spec(type=type, + client_factory = vim.client.factory + object_spec = build_object_spec(client_factory, + vim.get_service_content().rootFolder, + [build_recursive_traversal_spec(client_factory)]) + property_spec = build_property_spec(client_factory, type=type, properties_to_collect=properties_to_collect, all_properties=all) - property_filter_spec = build_property_filter_spec([property_spec], + property_filter_spec = build_property_filter_spec(client_factory, + [property_spec], [object_spec]) - return vim.RetrieveProperties(vim.get_service_content().PropertyCollector, + return vim.RetrieveProperties(vim.get_service_content().propertyCollector, specSet=[property_filter_spec]) -def get_traversal_spec(type, path, name="traversalSpec"): - """Builds the traversal spec object""" - t_spec = ns0.TraversalSpec_Def(name).pyclass() - t_spec._name = name - t_spec._type = type - t_spec._path = path - t_spec._skip = False - return t_spec - - -def get_prop_spec(type, properties): +def get_prop_spec(client_factory, type, properties): """Builds the Property Spec Object""" - prop_spec = ns0.PropertySpec_Def("PropertySpec").pyclass() - prop_spec._type = type - prop_spec._pathSet = properties + prop_spec = client_factory.create('ns0:PropertySpec') + prop_spec.type = type + prop_spec.pathSet = properties return prop_spec -def get_obj_spec(obj, select_set=None): +def get_obj_spec(client_factory, obj, select_set=None): """Builds the Object Spec object""" - obj_spec = ns0.ObjectSpec_Def("ObjectSpec").pyclass() - obj_spec._obj = obj - obj_spec._skip = False + obj_spec = client_factory.create('ns0:ObjectSpec') + obj_spec.obj = obj + obj_spec.skip = False if select_set is not None: - obj_spec._selectSet = select_set + obj_spec.selectSet = select_set return obj_spec -def get_prop_filter_spec(obj_spec, prop_spec): +def get_prop_filter_spec(client_factory, obj_spec, prop_spec): """Builds the Property Filter Spec Object""" prop_filter_spec = \ - ns0.PropertyFilterSpec_Def("PropertyFilterSpec").pyclass() - prop_filter_spec._propSet = prop_spec - prop_filter_spec._objectSet = obj_spec + client_factory.create('ns0:PropertyFilterSpec') + prop_filter_spec.propSet = prop_spec + prop_filter_spec.objectSet = obj_spec return prop_filter_spec def get_properites_for_a_collection_of_objects(vim, type, obj_list, properties): + """Gets the list of properties for the collection of + objects of the type specified """ - Gets the list of properties for the collection of objects of the - type specified - """ + client_factory = vim.client.factory if len(obj_list) == 0: return [] - prop_spec = get_prop_spec(type, properties) + prop_spec = get_prop_spec(client_factory, type, properties) lst_obj_specs = [] for obj in obj_list: - lst_obj_specs.append(get_obj_spec(obj)) - prop_filter_spec = get_prop_filter_spec(lst_obj_specs, [prop_spec]) - return vim.RetrieveProperties(vim.get_service_content().PropertyCollector, + lst_obj_specs.append(get_obj_spec(client_factory, obj)) + prop_filter_spec = get_prop_filter_spec(client_factory, + lst_obj_specs, [prop_spec]) + return vim.RetrieveProperties(vim.get_service_content().propertyCollector, specSet=[prop_filter_spec]) diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py index 05e49de83..a46b4d10c 100644 --- a/nova/virt/vmwareapi/vm_util.py +++ b/nova/virt/vmwareapi/vm_util.py @@ -14,24 +14,19 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. - """ -Utility functions to handle virtual disks, virtual network adapters, VMs etc. - +The VMware API VM utility module to build SOAP object specs """ -from nova.virt.vmwareapi.VimService_services_types import ns0 - def build_datastore_path(datastore_name, path): - """Builds the datastore compliant path.""" + """Build the datastore compliant path""" return "[%s] %s" % (datastore_name, path) def split_datastore_path(datastore_path): - """ - Split the VMWare style datastore path to get the Datastore name and the - entity path + """Split the VMWare style datastore path to get the Datastore + name and the entity path """ spl = datastore_path.split('[', 1)[1].split(']', 1) path = "" @@ -42,117 +37,95 @@ def split_datastore_path(datastore_path): return datastore_url, path.strip() -def get_vm_create_spec(instance, data_store_name, network_name="vmnet0", +def get_vm_create_spec(client_factory, instance, data_store_name, + network_name="vmnet0", os_type="otherGuest"): - """Builds the VM Create spec.""" - config_spec = ns0.VirtualMachineConfigSpec_Def( - "VirtualMachineConfigSpec").pyclass() - - config_spec._name = instance.name - config_spec._guestId = os_type + """Builds the VM Create spec""" + config_spec = client_factory.create('ns0:VirtualMachineConfigSpec') + config_spec.name = instance.name + config_spec.guestId = os_type - vm_file_info = ns0.VirtualMachineFileInfo_Def( - "VirtualMachineFileInfo").pyclass() - vm_file_info._vmPathName = "[" + data_store_name + "]" - config_spec._files = vm_file_info + vm_file_info = client_factory.create('ns0:VirtualMachineFileInfo') + vm_file_info.vmPathName = "[" + data_store_name + "]" + config_spec.files = vm_file_info - tools_info = ns0.ToolsConfigInfo_Def("ToolsConfigInfo") - tools_info._afterPowerOn = True - tools_info._afterResume = True - tools_info._beforeGuestStandby = True - tools_info._bbeforeGuestShutdown = True - tools_info._beforeGuestReboot = True + tools_info = client_factory.create('ns0:ToolsConfigInfo') + tools_info.afterPowerOn = True + tools_info.afterResume = True + tools_info.beforeGuestStandby = True + tools_info.beforeGuestShutdown = True + tools_info.beforeGuestReboot = True - config_spec._tools = tools_info - config_spec._numCPUs = int(instance.vcpus) - config_spec._memoryMB = int(instance.memory_mb) + config_spec.tools = tools_info + config_spec.numCPUs = int(instance.vcpus) + config_spec.memoryMB = int(instance.memory_mb) - nic_spec = create_network_spec(network_name, instance.mac_address) + nic_spec = create_network_spec(client_factory, + network_name, instance.mac_address) device_config_spec = [nic_spec] - config_spec._deviceChange = device_config_spec + config_spec.deviceChange = device_config_spec return config_spec -def create_controller_spec(key): - """ - Builds a Config Spec for the LSI Logic Controller's addition which acts - as the controller for the Virtual Hard disk to be attached to the VM +def create_controller_spec(client_factory, key): + """Builds a Config Spec for the LSI Logic Controller's addition + which acts as the controller for the + Virtual Hard disk to be attached to the VM """ #Create a controller for the Virtual Hard Disk virtual_device_config = \ - ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() - virtual_device_config._operation = "add" + client_factory.create('ns0:VirtualDeviceConfigSpec') + virtual_device_config.operation = "add" virtual_lsi = \ - ns0.VirtualLsiLogicController_Def( - "VirtualLsiLogicController").pyclass() - virtual_lsi._key = key - virtual_lsi._busNumber = 0 - virtual_lsi._sharedBus = "noSharing" - virtual_device_config._device = virtual_lsi - + client_factory.create('ns0:VirtualLsiLogicController') + virtual_lsi.key = key + virtual_lsi.busNumber = 0 + virtual_lsi.sharedBus = "noSharing" + virtual_device_config.device = virtual_lsi return virtual_device_config -def create_network_spec(network_name, mac_address): - """ - Builds a config spec for the addition of a new network adapter to - the VM. - """ +def create_network_spec(client_factory, network_name, mac_address): + """Builds a config spec for the addition of a new network + adapter to the VM""" network_spec = \ - ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() - network_spec._operation = "add" + client_factory.create('ns0:VirtualDeviceConfigSpec') + network_spec.operation = "add" #Get the recommended card type for the VM based on the guest OS of the VM - net_device = ns0.VirtualPCNet32_Def("VirtualPCNet32").pyclass() + net_device = client_factory.create('ns0:VirtualPCNet32') backing = \ - ns0.VirtualEthernetCardNetworkBackingInfo_Def( - "VirtualEthernetCardNetworkBackingInfo").pyclass() - backing._deviceName = network_name + client_factory.create('ns0:VirtualEthernetCardNetworkBackingInfo') + backing.deviceName = network_name connectable_spec = \ - ns0.VirtualDeviceConnectInfo_Def("VirtualDeviceConnectInfo").pyclass() - connectable_spec._startConnected = True - connectable_spec._allowGuestControl = True - connectable_spec._connected = True + client_factory.create('ns0:VirtualDeviceConnectInfo') + connectable_spec.startConnected = True + connectable_spec.allowGuestControl = True + connectable_spec.connected = True - net_device._connectable = connectable_spec - net_device._backing = backing + net_device.connectable = connectable_spec + net_device.backing = backing #The Server assigns a Key to the device. Here we pass a -ve temporary key. #-ve because actual keys are +ve numbers and we don't #want a clash with the key that server might associate with the device - net_device._key = -47 - net_device._addressType = "manual" - net_device._macAddress = mac_address - net_device._wakeOnLanEnabled = True + net_device.key = -47 + net_device.addressType = "manual" + net_device.macAddress = mac_address + net_device.wakeOnLanEnabled = True - network_spec._device = net_device + network_spec.device = net_device return network_spec -def get_datastore_search_sepc(pattern=None): - """Builds the datastore search spec.""" - host_datastore_browser_search_spec = \ - ns0.HostDatastoreBrowserSearchSpec_Def( - "HostDatastoreBrowserSearchSpec").pyclass() - file_query_flags = ns0.FileQueryFlags_Def("FileQueryFlags").pyclass() - file_query_flags._modification = False - file_query_flags._fileSize = True - file_query_flags._fileType = True - file_query_flags._fileOwner = True - host_datastore_browser_search_spec._details = file_query_flags - if pattern is not None: - host_datastore_browser_search_spec._matchPattern = pattern - return host_datastore_browser_search_spec - - -def get_vmdk_attach_config_sepc(disksize, file_path, adapter_type="lsiLogic"): - """Builds the vmdk attach config spec.""" - config_spec = ns0.VirtualMachineConfigSpec_Def( - "VirtualMachineConfigSpec").pyclass() +def get_vmdk_attach_config_spec(client_factory, + disksize, file_path, adapter_type="lsiLogic"): + """Builds the vmdk attach config spec""" + config_spec = client_factory.create('ns0:VirtualMachineConfigSpec') #The controller Key pertains to the Key of the LSI Logic Controller, which #controls this Hard Disk @@ -163,145 +136,165 @@ def get_vmdk_attach_config_sepc(disksize, file_path, adapter_type="lsiLogic"): controller_key = 200 else: controller_key = -101 - controller_spec = create_controller_spec(controller_key) + controller_spec = create_controller_spec(client_factory, + controller_key) device_config_spec.append(controller_spec) - virtual_device_config_spec = create_virtual_disk_spec(disksize, - controller_key, file_path) + virtual_device_config_spec = create_virtual_disk_spec(client_factory, + disksize, controller_key, file_path) device_config_spec.append(virtual_device_config_spec) - config_spec._deviceChange = device_config_spec + config_spec.deviceChange = device_config_spec return config_spec -def get_vmdk_file_path_and_adapter_type(hardware_devices): - """Gets the vmdk file path and the storage adapter type.""" - if isinstance(hardware_devices.typecode, ns0.ArrayOfVirtualDevice_Def): +def get_vmdk_file_path_and_adapter_type(client_factory, hardware_devices): + """Gets the vmdk file path and the storage adapter type""" + if hardware_devices.__class__.__name__ == "ArrayOfVirtualDevice": hardware_devices = hardware_devices.VirtualDevice vmdk_file_path = None vmdk_controler_key = None adapter_type_dict = {} for device in hardware_devices: - if (isinstance(device.typecode, ns0.VirtualDisk_Def) and - isinstance(device.Backing.typecode, - ns0.VirtualDiskFlatVer2BackingInfo_Def)): - vmdk_file_path = device.Backing.FileName - vmdk_controler_key = device.ControllerKey - elif isinstance(device.typecode, ns0.VirtualLsiLogicController_Def): - adapter_type_dict[device.Key] = "lsiLogic" - elif isinstance(device.typecode, ns0.VirtualBusLogicController_Def): - adapter_type_dict[device.Key] = "busLogic" - elif isinstance(device.typecode, ns0.VirtualIDEController_Def): - adapter_type_dict[device.Key] = "ide" - elif isinstance(device.typecode, ns0.VirtualLsiLogicSASController_Def): - adapter_type_dict[device.Key] = "lsiLogic" + if device.__class__.__name__ == "VirtualDisk" and \ + device.backing.__class__.__name__ \ + == "VirtualDiskFlatVer2BackingInfo": + vmdk_file_path = device.backing.fileName + vmdk_controler_key = device.controllerKey + elif device.__class__.__name__ == "VirtualLsiLogicController": + adapter_type_dict[device.key] = "lsiLogic" + elif device.__class__.__name__ == "VirtualBusLogicController": + adapter_type_dict[device.key] = "busLogic" + elif device.__class__.__name__ == "VirtualIDEController": + adapter_type_dict[device.key] = "ide" + elif device.__class__.__name__ == "VirtualLsiLogicSASController": + adapter_type_dict[device.key] = "lsiLogic" adapter_type = adapter_type_dict.get(vmdk_controler_key, "") return vmdk_file_path, adapter_type -def get_copy_virtual_disk_spec(adapter_type="lsilogic"): - """Builds the Virtual Disk copy spec.""" - dest_spec = ns0.VirtualDiskSpec_Def("VirtualDiskSpec").pyclass() - dest_spec.AdapterType = adapter_type - dest_spec.DiskType = "thick" +def get_copy_virtual_disk_spec(client_factory, adapter_type="lsilogic"): + """Builds the Virtual Disk copy spec""" + dest_spec = client_factory.create('ns0:VirtualDiskSpec') + dest_spec.adapterType = adapter_type + dest_spec.diskType = "thick" return dest_spec -def get_vmdk_create_spec(size_in_kb, adapter_type="lsiLogic"): - """Builds the virtual disk create sepc.""" +def get_vmdk_create_spec(client_factory, size_in_kb, adapter_type="lsiLogic"): + """Builds the virtual disk create spec""" create_vmdk_spec = \ - ns0.FileBackedVirtualDiskSpec_Def("VirtualDiskSpec").pyclass() - create_vmdk_spec._adapterType = adapter_type - create_vmdk_spec._diskType = "thick" - create_vmdk_spec._capacityKb = size_in_kb + client_factory.create('ns0:FileBackedVirtualDiskSpec') + create_vmdk_spec.adapterType = adapter_type + create_vmdk_spec.diskType = "thick" + create_vmdk_spec.capacityKb = size_in_kb return create_vmdk_spec -def create_virtual_disk_spec(disksize, controller_key, file_path=None): - """Creates a Spec for the addition/attaching of a Virtual Disk to the VM""" +def create_virtual_disk_spec(client_factory, + disksize, controller_key, file_path=None): + """Creates a Spec for the addition/attaching of a + Virtual Disk to the VM""" virtual_device_config = \ - ns0.VirtualDeviceConfigSpec_Def("VirtualDeviceConfigSpec").pyclass() - virtual_device_config._operation = "add" + client_factory.create('ns0:VirtualDeviceConfigSpec') + virtual_device_config.operation = "add" if file_path is None: - virtual_device_config._fileOperation = "create" + virtual_device_config.fileOperation = "create" - virtual_disk = ns0.VirtualDisk_Def("VirtualDisk").pyclass() + virtual_disk = client_factory.create('ns0:VirtualDisk') - disk_file_backing = ns0.VirtualDiskFlatVer2BackingInfo_Def( - "VirtualDiskFlatVer2BackingInfo").pyclass() - disk_file_backing._diskMode = "persistent" - disk_file_backing._thinProvisioned = False + disk_file_backing = \ + client_factory.create('ns0:VirtualDiskFlatVer2BackingInfo') + disk_file_backing.diskMode = "persistent" + disk_file_backing.thinProvisioned = False if file_path is not None: - disk_file_backing._fileName = file_path + disk_file_backing.fileName = file_path else: - disk_file_backing._fileName = "" + disk_file_backing.fileName = "" - connectable_spec = ns0.VirtualDeviceConnectInfo_Def( - "VirtualDeviceConnectInfo").pyclass() - connectable_spec._startConnected = True - connectable_spec._allowGuestControl = False - connectable_spec._connected = True + connectable_spec = client_factory.create('ns0:VirtualDeviceConnectInfo') + connectable_spec.startConnected = True + connectable_spec.allowGuestControl = False + connectable_spec.connected = True - virtual_disk._backing = disk_file_backing - virtual_disk._connectable = connectable_spec + virtual_disk.backing = disk_file_backing + virtual_disk.connectable = connectable_spec #The Server assigns a Key to the device. Here we pass a -ve temporary key. #-ve because actual keys are +ve numbers and we don't #want a clash with the key that server might associate with the device - virtual_disk._key = -100 - virtual_disk._controllerKey = controller_key - virtual_disk._unitNumber = 0 - virtual_disk._capacityInKB = disksize + virtual_disk.key = -100 + virtual_disk.controllerKey = controller_key + virtual_disk.unitNumber = 0 + virtual_disk.capacityInKB = disksize - virtual_device_config._device = virtual_disk + virtual_device_config.device = virtual_disk return virtual_device_config -def get_dummy_vm_create_spec(name, data_store_name): - """Builds the dummy VM create spec.""" - config_spec = ns0.VirtualMachineConfigSpec_Def( - "VirtualMachineConfigSpec").pyclass() +def get_dummy_vm_create_spec(client_factory, name, data_store_name): + """Builds the dummy VM create spec""" + config_spec = client_factory.create('ns0:VirtualMachineConfigSpec') - config_spec._name = name - config_spec._guestId = "otherGuest" + config_spec.name = name + config_spec.guestId = "otherGuest" - vm_file_info = ns0.VirtualMachineFileInfo_Def( - "VirtualMachineFileInfo").pyclass() - vm_file_info._vmPathName = "[" + data_store_name + "]" - config_spec._files = vm_file_info + vm_file_info = client_factory.create('ns0:VirtualMachineFileInfo') + vm_file_info.vmPathName = "[" + data_store_name + "]" + config_spec.files = vm_file_info - tools_info = ns0.ToolsConfigInfo_Def("ToolsConfigInfo") - tools_info._afterPowerOn = True - tools_info._afterResume = True - tools_info._beforeGuestStandby = True - tools_info._bbeforeGuestShutdown = True - tools_info._beforeGuestReboot = True + tools_info = client_factory.create('ns0:ToolsConfigInfo') + tools_info.afterPowerOn = True + tools_info.afterResume = True + tools_info.beforeGuestStandby = True + tools_info.beforeGuestShutdown = True + tools_info.beforeGuestReboot = True - config_spec._tools = tools_info - config_spec._numCPUs = 1 - config_spec._memoryMB = 4 + config_spec.tools = tools_info + config_spec.numCPUs = 1 + config_spec.memoryMB = 4 controller_key = -101 - controller_spec = create_controller_spec(controller_key) - disk_spec = create_virtual_disk_spec(1024, controller_key) + controller_spec = create_controller_spec(client_factory, controller_key) + disk_spec = create_virtual_disk_spec(client_factory, 1024, controller_key) device_config_spec = [controller_spec, disk_spec] - config_spec._deviceChange = device_config_spec + config_spec.deviceChange = device_config_spec return config_spec -def get_machine_id_change_spec(mac, ip_addr, netmask, gateway): - """Builds the machine id change config spec.""" +def get_machine_id_change_spec(client_factory, mac, ip_addr, netmask, gateway): + """Builds the machine id change config spec""" machine_id_str = "%s;%s;%s;%s" % (mac, ip_addr, netmask, gateway) - virtual_machine_config_spec = ns0.VirtualMachineConfigSpec_Def( - "VirtualMachineConfigSpec").pyclass() - opt = ns0.OptionValue_Def('OptionValue').pyclass() - opt._key = "machine.id" - opt._value = machine_id_str - virtual_machine_config_spec._extraConfig = [opt] + virtual_machine_config_spec = \ + client_factory.create('ns0:VirtualMachineConfigSpec') + + opt = client_factory.create('ns0:OptionValue') + opt.key = "machine.id" + opt.value = machine_id_str + virtual_machine_config_spec.extraConfig = [opt] return virtual_machine_config_spec + + +def get_add_vswitch_port_group_spec(client_factory, vswitch_name, + port_group_name, vlan_id): + """Builds the virtual switch port group add spec""" + vswitch_port_group_spec = client_factory.create('ns0:HostPortGroupSpec') + vswitch_port_group_spec.name = port_group_name + vswitch_port_group_spec.vswitchName = vswitch_name + + #VLAN ID of 0 means that VLAN tagging is not to be done for the network. + vswitch_port_group_spec.vlanId = int(vlan_id) + + policy = client_factory.create('ns0:HostNetworkPolicy') + nicteaming = client_factory.create('ns0:HostNicTeamingPolicy') + nicteaming.notifySwitches = True + policy.nicTeaming = nicteaming + + vswitch_port_group_spec.policy = policy + return vswitch_port_group_spec diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index 3e32fceef..c2e6d9bf8 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -17,20 +17,27 @@ """ Class for VM tasks like spawn, snapshot, suspend, resume etc. - """ -import logging + +import base64 import os import time +import urllib +import urllib2 import uuid -from nova import db from nova import context +from nova import db +from nova import exception +from nova import flags +from nova import log as logging from nova.compute import power_state from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi import vm_util from nova.virt.vmwareapi import vmware_images +from nova.virt.vmwareapi.network_utils import NetworkHelper +FLAGS = flags.FLAGS LOG = logging.getLogger("nova.virt.vmwareapi.vmops") VMWARE_POWER_STATES = { @@ -40,14 +47,14 @@ VMWARE_POWER_STATES = { class VMWareVMOps(object): - """Management class for VM-related tasks""" + """ Management class for VM-related tasks """ def __init__(self, session): - """Initializer""" + """ Initializer """ self._session = session def _wait_with_callback(self, instance_id, task, callback): - """Waits for the task to finish and does a callback after""" + """ Waits for the task to finish and does a callback after """ ret = None try: ret = self._session._wait_for_task(instance_id, task) @@ -56,7 +63,7 @@ class VMWareVMOps(object): callback(ret) def list_instances(self): - """Lists the VM instances that are registered with the ESX host""" + """ Lists the VM instances that are registered with the ESX host """ LOG.debug(_("Getting list of instances")) vms = self._session._call_method(vim_util, "get_objects", "VirtualMachine", @@ -65,11 +72,11 @@ class VMWareVMOps(object): for vm in vms: vm_name = None conn_state = None - for prop in vm.PropSet: - if prop.Name == "name": - vm_name = prop.Val - elif prop.Name == "runtime.connectionState": - conn_state = prop.Val + for prop in vm.propSet: + if prop.name == "name": + vm_name = prop.val + elif prop.name == "runtime.connectionState": + conn_state = prop.val # Ignoring the oprhaned or inaccessible VMs if conn_state not in ["orphaned", "inaccessible"]: lst_vm_names.append(vm_name) @@ -93,18 +100,19 @@ class VMWareVMOps(object): """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref: - raise Exception('Attempted to create a VM with a name %s, ' - 'but that already exists on the host' % instance.name) - bridge = db.network_get_by_instance(context.get_admin_context(), - instance['id'])['bridge'] - #TODO(sateesh): Shouldn't we consider any public network in case - #the network name supplied isn't there + raise Exception(_("Attempted to create a VM with a name %s, " + "but that already exists on the host") % instance.name) + + client_factory = self._session._get_vim().client.factory + + network = db.network_get_by_instance(context.get_admin_context(), + instance['id']) + net_name = network['bridge'] network_ref = \ - self._get_network_with_the_name(bridge) + NetworkHelper.get_network_with_the_name(self._session, net_name) if network_ref is None: - raise Exception("Network with the name '%s' doesn't exist on " - "the ESX host" % bridge) - + raise Exception(_("Network with the name '%s' doesn't exist on" + " the ESX host") % net_name) #Get the Size of the flat vmdk file that is there on the storage #repository. image_size, image_properties = \ @@ -121,11 +129,11 @@ class VMWareVMOps(object): for elem in data_stores: ds_name = None ds_type = None - for prop in elem.PropSet: - if prop.Name == "summary.type": - ds_type = prop.Val - elif prop.Name == "summary.name": - ds_name = prop.Val + for prop in elem.propSet: + if prop.name == "summary.type": + ds_type = prop.val + elif prop.name == "summary.name": + ds_name = prop.val #Local storage identifier if ds_type == "VMFS": data_store_name = ds_name @@ -135,22 +143,21 @@ class VMWareVMOps(object): msg = _("Couldn't get a local Datastore reference") LOG.exception(msg) raise Exception(msg) - - config_spec = vm_util.get_vm_create_spec(instance, data_store_name, - bridge, os_type) + config_spec = vm_util.get_vm_create_spec(client_factory, instance, + data_store_name, net_name, os_type) #Get the Vm folder ref from the datacenter dc_objs = self._session._call_method(vim_util, "get_objects", "Datacenter", ["vmFolder"]) #There is only one default datacenter in a standalone ESX host - vm_folder_ref = dc_objs[0].PropSet[0].Val + vm_folder_ref = dc_objs[0].propSet[0].val #Get the resource pool. Taking the first resource pool coming our way. #Assuming that is the default resource pool. res_pool_mor = self._session._call_method(vim_util, "get_objects", - "ResourcePool")[0].Obj + "ResourcePool")[0].obj - LOG.debug(_("Creating VM with the name %s on the ESX host") % \ + LOG.debug(_("Creating VM with the name %s on the ESX host") % instance.name) #Create the VM on the ESX host vm_create_task = self._session._call_method(self._session._get_vim(), @@ -158,11 +165,11 @@ class VMWareVMOps(object): config=config_spec, pool=res_pool_mor) self._session._wait_for_task(instance.id, vm_create_task) - LOG.debug(_("Created VM with the name %s on the ESX host") % \ + LOG.debug(_("Created VM with the name %s on the ESX host") % instance.name) # Set the machine id for the VM for setting the IP - self._set_machine_id(instance) + self._set_machine_id(client_factory, instance) #Naming the VM files in correspondence with the VM instance name @@ -181,61 +188,56 @@ class VMWareVMOps(object): #depend on the size of the disk, thin/thick provisioning and the #storage adapter type. #Here we assume thick provisioning and lsiLogic for the adapter type - LOG.debug(_("Creating Virtual Disk of size %(vmdk_file_size_in_kb)sKB" - " and adapter type %(adapter_type)s on" - " the ESX host local store %(data_store_name)s") % - {'vmdk_file_size_in_kb': vmdk_file_size_in_kb, - 'adapter_type': adapter_type, - 'data_store_name': data_store_name}) - vmdk_create_spec = vm_util.get_vmdk_create_spec(vmdk_file_size_in_kb, - adapter_type) + LOG.debug(_("Creating Virtual Disk of size %(vmdk_file_size_in_kb)s " + "KB and adapter type %(adapter_type)s on " + "the ESX host local store %(data_store_name)s") % locals()) + vmdk_create_spec = vm_util.get_vmdk_create_spec(client_factory, + vmdk_file_size_in_kb, adapter_type) vmdk_create_task = self._session._call_method(self._session._get_vim(), "CreateVirtualDisk_Task", - self._session._get_vim().get_service_content().VirtualDiskManager, + self._session._get_vim().get_service_content().virtualDiskManager, name=uploaded_vmdk_path, datacenter=self._get_datacenter_name_and_ref()[0], spec=vmdk_create_spec) self._session._wait_for_task(instance.id, vmdk_create_task) - LOG.debug(_("Created Virtual Disk of size %(vmdk_file_size_in_kb)s KB" - " on the ESX host local store %(data_store_name)s ") % - {'vmdk_file_size_in_kb': vmdk_file_size_in_kb, - 'data_store_name': data_store_name}) - - LOG.debug(_("Deleting the file %(flat_uploaded_vmdk_path)s on " - "the ESX host local store %(data_store_names)s") % - {'flat_uploaded_vmdk_path': flat_uploaded_vmdk_path, - 'data_store_name': data_store_name}) + LOG.debug(_("Created Virtual Disk of size %(vmdk_file_size_in_kb)s " + "KB on the ESX host local store " + "%(data_store_name)s") % locals()) + + LOG.debug(_("Deleting the file %(flat_uploaded_vmdk_path)s " + "on the ESX host local" + "store %(data_store_name)s") % locals()) #Delete the -flat.vmdk file created. .vmdk file is retained. vmdk_delete_task = self._session._call_method(self._session._get_vim(), "DeleteDatastoreFile_Task", - self._session._get_vim().get_service_content().FileManager, + self._session._get_vim().get_service_content().fileManager, name=flat_uploaded_vmdk_path) self._session._wait_for_task(instance.id, vmdk_delete_task) - LOG.debug(_("Deleted the file %(flat_uploaded_vmdk_path)s on " - "the ESX host local store %(data_store_name)s ") % - {'flat_uploaded_vmdk_path': flat_uploaded_vmdk_path, - 'data_store_name': data_store_name}) - - LOG.debug(_("Downloading image file %(image_id)s to the " - "ESX data store %(datastore_name)s ") % - {'image_id': instance.image_id, - 'data_store_name': data_store_name}) + LOG.debug(_("Deleted the file %(flat_uploaded_vmdk_path)s on the " + "ESX host local store %(data_store_name)s") % locals()) + + LOG.debug(_("Downloading image file data %(image_id)s to the ESX " + "data store %(data_store_name)s") % + ({'image_id': instance.image_id, + 'data_store_name': data_store_name})) + cookies = self._session._get_vim().client.options.transport.cookiejar # Upload the -flat.vmdk file whose meta-data file we just created above vmware_images.fetch_image( - instance.image_id, - instance, - host=self._session._host_ip, - data_center_name=self._get_datacenter_name_and_ref()[1], - datastore_name=data_store_name, - cookies=self._session._get_vim().proxy.binding.cookies, - file_path=flat_uploaded_vmdk_name) - LOG.debug(_("Downloaded image file %(image_id)s to the ESX data " - "store %(data_store_name)s ") % - {'image_id': instance.image_id, - 'data_store_name': data_store_name}) + instance.image_id, + instance, + host=self._session._host_ip, + data_center_name=self._get_datacenter_name_and_ref()[1], + datastore_name=data_store_name, + cookies=cookies, + file_path=flat_uploaded_vmdk_name) + LOG.debug(_("Downloaded image file data %(image_id)s to the ESX " + "data store %(data_store_name)s") % + ({'image_id': instance.image_id, + 'data_store_name': data_store_name})) #Attach the vmdk uploaded to the VM. VM reconfigure is done to do so. - vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_sepc( + vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_spec( + client_factory, vmdk_file_size_in_kb, uploaded_vmdk_path, adapter_type) vm_ref = self._get_vm_ref_from_the_name(instance.name) @@ -248,12 +250,12 @@ class VMWareVMOps(object): LOG.debug(_("Reconfigured VM instance %s to attach the image " "disk") % instance.name) - LOG.debug(_("Powering on the VM instance %s ") % instance.name) + LOG.debug(_("Powering on the VM instance %s") % instance.name) #Power On the VM power_on_task = self._session._call_method(self._session._get_vim(), "PowerOnVM_Task", vm_ref) self._session._wait_for_task(instance.id, power_on_task) - LOG.debug(_("Powered on the VM instance %s ") % instance.name) + LOG.debug(_("Powered on the VM instance %s") % instance.name) def snapshot(self, instance, snapshot_name): """ @@ -277,14 +279,17 @@ class VMWareVMOps(object): hardware_devices = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "config.hardware.device") + client_factory = self._session._get_vim().client.factory vmdk_file_path_before_snapshot, adapter_type = \ - vm_util.get_vmdk_file_path_and_adapter_type(hardware_devices) + vm_util.get_vmdk_file_path_and_adapter_type(client_factory, + hardware_devices) os_type = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "summary.config.guestId") #Create a snapshot of the VM - LOG.debug(_("Creating Snapshot of the VM instance %s") % instance.name) + LOG.debug(_("Creating Snapshot of the VM instance %s ") % + instance.name) snapshot_task = self._session._call_method(self._session._get_vim(), "CreateSnapshot_Task", vm_ref, name="%s-snapshot" % instance.name, @@ -313,7 +318,8 @@ class VMWareVMOps(object): self._mkdir(vm_util.build_datastore_path(datastore_name, "vmware-tmp")) - copy_spec = vm_util.get_copy_virtual_disk_spec(adapter_type) + copy_spec = vm_util.get_copy_virtual_disk_spec(client_factory, + adapter_type) #Generate a random vmdk file name to which the coalesced vmdk content #will be copied to. A random name is chosen so that we don't have @@ -325,11 +331,11 @@ class VMWareVMOps(object): #Copy the contents of the disk ( or disks, if there were snapshots #done earlier) to a temporary vmdk file. - LOG.debug(_("Copying disk data before snapshot of " - "the VM instance %s") % instance.name) + LOG.debug(_("Copying disk data before snapshot of the VM instance %s") + % instance.name) copy_disk_task = self._session._call_method(self._session._get_vim(), "CopyVirtualDisk_Task", - self._session._get_vim().get_service_content().VirtualDiskManager, + self._session._get_vim().get_service_content().virtualDiskManager, sourceName=vmdk_file_path_before_snapshot, sourceDatacenter=dc_ref, destName=dest_vmdk_file_location, @@ -337,38 +343,39 @@ class VMWareVMOps(object): destSpec=copy_spec, force=False) self._session._wait_for_task(instance.id, copy_disk_task) - LOG.debug(_("Copied disk data before snapshot of " - "the VM instance %s") % instance.name) + LOG.debug(_("Copied disk data before snapshot of the VM instance %s") + % instance.name) + cookies = self._session._get_vim().client.options.transport.cookiejar #Upload the contents of -flat.vmdk file which has the disk data. LOG.debug(_("Uploading image %s") % snapshot_name) vmware_images.upload_image( - snapshot_name, - instance, - os_type=os_type, - adapter_type=adapter_type, - image_version=1, - host=self._session._host_ip, - data_center_name=self._get_datacenter_name_and_ref()[1], - datastore_name=datastore_name, - cookies=self._session._get_vim().proxy.binding.cookies, - file_path="vmware-tmp/%s-flat.vmdk" % random_name) + snapshot_name, + instance, + os_type=os_type, + adapter_type=adapter_type, + image_version=1, + host=self._session._host_ip, + data_center_name=self._get_datacenter_name_and_ref()[1], + datastore_name=datastore_name, + cookies=cookies, + file_path="vmware-tmp/%s-flat.vmdk" % random_name) LOG.debug(_("Uploaded image %s") % snapshot_name) #Delete the temporary vmdk created above. - LOG.debug(_("Deleting temporary vmdk file %s") % \ - dest_vmdk_file_location) + LOG.debug(_("Deleting temporary vmdk file %s") + % dest_vmdk_file_location) remove_disk_task = self._session._call_method(self._session._get_vim(), "DeleteVirtualDisk_Task", - self._session._get_vim().get_service_content().VirtualDiskManager, + self._session._get_vim().get_service_content().virtualDiskManager, name=dest_vmdk_file_location, datacenter=dc_ref) self._session._wait_for_task(instance.id, remove_disk_task) - LOG.debug(_("Deleted temporary vmdk file %s") % \ - dest_vmdk_file_location) + LOG.debug(_("Deleted temporary vmdk file %s") + % dest_vmdk_file_location) def reboot(self, instance): - """Reboot a VM instance""" + """ Reboot a VM instance """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise Exception(_("instance - %s not present") % instance.name) @@ -379,11 +386,11 @@ class VMWareVMOps(object): for elem in props: pwr_state = None tools_status = None - for prop in elem.PropSet: - if prop.Name == "runtime.powerState": - pwr_state = prop.Val - elif prop.Name == "summary.guest.toolsStatus": - tools_status = prop.Val + for prop in elem.propSet: + if prop.name == "runtime.powerState": + pwr_state = prop.val + elif prop.name == "summary.guest.toolsStatus": + tools_status = prop.val #Raise an exception if the VM is not powered On. if pwr_state not in ["poweredOn"]: @@ -423,11 +430,11 @@ class VMWareVMOps(object): pwr_state = None for elem in props: vm_config_pathname = None - for prop in elem.PropSet: - if prop.Name == "runtime.powerState": - pwr_state = prop.Val - elif prop.Name == "config.files.vmPathName": - vm_config_pathname = prop.Val + for prop in elem.propSet: + if prop.name == "runtime.powerState": + pwr_state = prop.val + elif prop.name == "config.files.vmPathName": + vm_config_pathname = prop.val if vm_config_pathname: datastore_name, vmx_file_path = \ vm_util.split_datastore_path(vm_config_pathname) @@ -447,48 +454,49 @@ class VMWareVMOps(object): "UnregisterVM", vm_ref) LOG.debug(_("Unregistered the VM %s") % instance.name) except Exception, excep: - LOG.warn(_("In vmwareapi:vmops:destroy, got this exception " - "while un-registering the VM: ") + str(excep)) + LOG.warn(_("In vmwareapi:vmops:destroy, got this exception" + " while un-registering the VM: %s") % str(excep)) #Delete the folder holding the VM related content on the datastore. try: dir_ds_compliant_path = vm_util.build_datastore_path( datastore_name, os.path.dirname(vmx_file_path)) - LOG.debug(_("Deleting contents of the VM %(instance.name)s " - "from datastore %(datastore_name)s") % - {('instance.name': instance.name, - 'datastore_name': datastore_name)}) + LOG.debug(_("Deleting contents of the VM %(name)s from " + "datastore %(datastore_name)s") % + ({'name': instance.name, + 'datastore_name': datastore_name})) delete_task = self._session._call_method( self._session._get_vim(), "DeleteDatastoreFile_Task", - self._session._get_vim().get_service_content().FileManager, + self._session._get_vim().get_service_content().fileManager, name=dir_ds_compliant_path) self._session._wait_for_task(instance.id, delete_task) - LOG.debug(_("Deleted contents of the VM %(instance_name)s " - "from datastore %(datastore_name)s") % - {'instance_name': instance.name, - 'datastore_name': datastore_name}) + LOG.debug(_("Deleted contents of the VM %(name)s from " + "datastore %(datastore_name)s") + ({'name': instance.name, + 'datastore_name': datastore_name})) except Exception, excep: LOG.warn(_("In vmwareapi:vmops:destroy, " "got this exception while deleting" - " the VM contents from the disk: ") + str(excep)) + " the VM contents from the disk: %s") + % str(excep)) except Exception, e: LOG.exception(e) def pause(self, instance, callback): - """Pause a VM instance""" - return "Not Implemented" + """ Pause a VM instance """ + raise exception.APIError("pause not supported for vmwareapi") def unpause(self, instance, callback): - """Un-Pause a VM instance""" - return "Not Implemented" + """ Un-Pause a VM instance """ + raise exception.APIError("unpause not supported for vmwareapi") def suspend(self, instance, callback): - """Suspend the specified instance""" + """ Suspend the specified instance """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception("instance - %s not present" % instance.name) + raise Exception(_("instance - %s not present") % instance.name) pwr_state = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, @@ -505,10 +513,10 @@ class VMWareVMOps(object): raise Exception(_("instance - %s is poweredOff and hence can't " "be suspended.") % instance.name) LOG.debug(_("VM %s was already in suspended state. So returning " - "without doing anything") % instance.name) + "without doing anything") % instance.name) def resume(self, instance, callback): - """Resume the specified instance""" + """ Resume the specified instance """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise Exception(_("instance - %s not present") % instance.name) @@ -517,7 +525,7 @@ class VMWareVMOps(object): "get_dynamic_property", vm_ref, "VirtualMachine", "runtime.powerState") if pwr_state.lower() == "suspended": - LOG.debug(_("Resuming the VM %s ") % instance.name) + LOG.debug(_("Resuming the VM %s") % instance.name) suspend_task = self._session._call_method( self._session._get_vim(), "PowerOnVM_Task", vm_ref) @@ -528,7 +536,7 @@ class VMWareVMOps(object): "can't be Resumed.") % instance.name) def get_info(self, instance_name): - """Return data about the VM instance""" + """ Return data about the VM instance """ vm_ref = self._get_vm_ref_from_the_name(instance_name) if vm_ref is None: raise Exception(_("instance - %s not present") % instance_name) @@ -543,14 +551,14 @@ class VMWareVMOps(object): pwr_state = None num_cpu = None for elem in vm_props: - for prop in elem.PropSet: - if prop.Name == "summary.config.numCpu": - num_cpu = int(prop.Val) - elif prop.Name == "summary.config..memorySizeMB": + for prop in elem.propSet: + if prop.name == "summary.config.numCpu": + num_cpu = int(prop.val) + elif prop.name == "summary.config.memorySizeMB": # In MB, but we want in KB - max_mem = int(prop.Val) * 1024 - elif prop.Name == "runtime.powerState": - pwr_state = VMWARE_POWER_STATES[prop.Val] + max_mem = int(prop.val) * 1024 + elif prop.name == "runtime.powerState": + pwr_state = VMWARE_POWER_STATES[prop.val] return {'state': pwr_state, 'max_mem': max_mem, @@ -559,22 +567,38 @@ class VMWareVMOps(object): 'cpu_time': 0} def get_diagnostics(self, instance): - """Return data about VM diagnostics""" - return "Not Implemented" + """ Return data about VM diagnostics """ + raise exception.APIError("get_diagnostics not implemented for " + "vmwareapi") def get_console_output(self, instance): - """Return snapshot of console""" - return 'FAKE CONSOLE OUTPUT of instance' + """ Return snapshot of console """ + vm_ref = self._get_vm_ref_from_the_name(instance.name) + if vm_ref is None: + raise Exception(_("instance - %s not present") % instance.name) + param_list = {"id": str(vm_ref)} + base_url = "%s://%s/screen?%s" % (self._session._scheme, + self._session._host_ip, + urllib.urlencode(param_list)) + request = urllib2.Request(base_url) + base64string = base64.encodestring( + '%s:%s' % ( + self._session._host_username, + self._session._host_password)).replace('\n', '') + request.add_header("Authorization", "Basic %s" % base64string) + result = urllib2.urlopen(request) + if result.code == 200: + return result.read() + else: + return "" def get_ajax_console(self, instance): - """Return link to instance's ajax console""" + """ Return link to instance's ajax console """ return 'http://fakeajaxconsole/fake_url' - def _set_machine_id(self, instance): - """ - Set the machine id of the VM for guest tools to pick up - and change the IP - """ + def _set_machine_id(self, client_factory, instance): + """ Set the machine id of the VM for guest tools to pick up and change + the IP """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise Exception(_("instance - %s not present") % instance.name) @@ -585,95 +609,30 @@ class VMWareVMOps(object): gateway = network["gateway"] ip_addr = db.instance_get_fixed_address(context.get_admin_context(), instance['id']) - machine_id_chanfge_spec = vm_util.get_machine_id_change_spec(mac_addr, + machine_id_chanfge_spec = \ + vm_util.get_machine_id_change_spec(client_factory, mac_addr, ip_addr, net_mask, gateway) - LOG.debug(_("Reconfiguring VM instance %(instance_name)s to set " - "the machine id with ip - %(ip_addr)s") % - {'instance_name': instance.name, - 'ip_addr': ip_addr}) + LOG.debug(_("Reconfiguring VM instance %(name)s to set the machine id " + "with ip - %(ip_addr)s") % + ({'name': instance.name, + 'ip_addr': ip_addr})) reconfig_task = self._session._call_method(self._session._get_vim(), "ReconfigVM_Task", vm_ref, spec=machine_id_chanfge_spec) self._session._wait_for_task(instance.id, reconfig_task) - LOG.debug(_("Reconfigured VM instance %(instance_name)s to set " - "the machine id with ip - %(ip_addr)s") % - {'instance_name': instance.name, - 'ip_addr': ip_addr}) - - def _create_dummy_vm_for_test(self, instance): - """Create a dummy VM for testing purpose""" - vm_ref = self._get_vm_ref_from_the_name(instance.name) - if vm_ref: - raise Exception(_('Attempted to create a VM with a name %s, ' - 'but that already exists on the host') % instance.name) - - data_stores = self._session._call_method(vim_util, "get_objects", - "Datastore", ["summary.type", "summary.name"]) - data_store_name = None - for elem in data_stores: - ds_name = None - ds_type = None - for prop in elem.PropSet: - if prop.Name == "summary.type": - ds_type = prop.Val - elif prop.Name == "summary.name": - ds_name = prop.Val - #Local storage identifier - if ds_type == "VMFS": - data_store_name = ds_name - break - - if data_store_name is None: - msg = _("Couldn't get a local Datastore reference") - LOG.exception(msg) - raise Exception(msg) - - config_spec = vm_util.get_dummy_vm_create_spec(instance.name, - data_store_name) - - #Get the Vm folder ref from the datacenter - dc_objs = self._session._call_method(vim_util, "get_objects", - "Datacenter", ["vmFolder"]) - #There is only one default datacenter in a standalone ESX host - vm_folder_ref = dc_objs[0].PropSet[0].Val - - #Get the resource pool. Taking the first resource pool coming our way. - #Assuming that is the default resource pool. - res_pool_mor = self._session._call_method(vim_util, "get_objects", - "ResourcePool")[0].Obj - - #Create the VM on the ESX host - vm_create_task = self._session._call_method(self._session._get_vim(), - "CreateVM_Task", vm_folder_ref, - config=config_spec, pool=res_pool_mor) - self._session._wait_for_task(instance.id, vm_create_task) - - vm_ref = self._get_vm_ref_from_the_name(instance.name) - power_on_task = self._session._call_method(self._session._get_vim(), - "PowerOnVM_Task", vm_ref) - self._session._wait_for_task(instance.id, power_on_task) - - def _get_network_with_the_name(self, network_name="vmnet0"): - """Gets reference to network whose name is passed as the argument.""" - datacenters = self._session._call_method(vim_util, "get_objects", - "Datacenter", ["network"]) - vm_networks = datacenters[0].PropSet[0].Val.ManagedObjectReference - networks = self._session._call_method(vim_util, - "get_properites_for_a_collection_of_objects", - "Network", vm_networks, ["summary.name"]) - for network in networks: - if network.PropSet[0].Val == network_name: - return network.Obj - return None + LOG.debug(_("Reconfigured VM instance %(name)s to set the machine id " + "with ip - %(ip_addr)s") % + ({'name': instance.name, + 'ip_addr': ip_addr})) def _get_datacenter_name_and_ref(self): - """Get the datacenter name and the reference.""" + """ Get the datacenter name and the reference. """ dc_obj = self._session._call_method(vim_util, "get_objects", "Datacenter", ["name"]) - return dc_obj[0].Obj, dc_obj[0].PropSet[0].Val + return dc_obj[0].obj, dc_obj[0].propSet[0].val def _path_exists(self, ds_browser, ds_path): - """Check if the path exists on the datastore.""" + """Check if the path exists on the datastore""" search_task = self._session._call_method(self._session._get_vim(), "SearchDatastore_Task", ds_browser, @@ -684,31 +643,29 @@ class VMWareVMOps(object): task_info = self._session._call_method(vim_util, "get_dynamic_property", search_task, "Task", "info") - if task_info.State in ['queued', 'running']: + if task_info.state in ['queued', 'running']: time.sleep(2) continue break - if task_info.State == "error": + if task_info.state == "error": return False return True def _mkdir(self, ds_path): - """ - Creates a directory at the path specified. If it is just "NAME", then a - directory with this name is formed at the topmost level of the - DataStore. - """ + """ Creates a directory at the path specified. If it is just "NAME", + then a directory with this name is formed at the topmost level of the + DataStore. """ LOG.debug(_("Creating directory with path %s") % ds_path) self._session._call_method(self._session._get_vim(), "MakeDirectory", - self._session._get_vim().get_service_content().FileManager, + self._session._get_vim().get_service_content().fileManager, name=ds_path, createParentDirectories=False) LOG.debug(_("Created directory with path %s") % ds_path) def _get_vm_ref_from_the_name(self, vm_name): - """Get reference to the VM with the name specified.""" + """ Get reference to the VM with the name specified. """ vms = self._session._call_method(vim_util, "get_objects", "VirtualMachine", ["name"]) for vm in vms: - if vm.PropSet[0].Val == vm_name: - return vm.Obj + if vm.propSet[0].val == vm_name: + return vm.obj return None diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py index 4aad657e6..f2a7c3b33 100644 --- a/nova/virt/vmwareapi/vmware_images.py +++ b/nova/virt/vmwareapi/vmware_images.py @@ -14,19 +14,16 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. - """ -Utility functions to handle vm images. Also include fake image handlers. - +Utility functions for Image transfer """ -import logging -import os import time from nova import flags -from nova.virt.vmwareapi import read_write_util +from nova import log as logging from nova.virt.vmwareapi import io_util +from nova.virt.vmwareapi import read_write_util FLAGS = flags.FLAGS @@ -35,11 +32,11 @@ READ_CHUNKSIZE = 2 * 1024 * 1024 WRITE_CHUNKSIZE = 2 * 1024 * 1024 LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images") -TEST_IMAGE_PATH = "/tmp/vmware-test-images" def start_transfer(read_file_handle, write_file_handle, data_size): - """Start the data transfer from the read handle to the write handle.""" + """ Start the data transfer from the read handle to the write handle. """ + #The thread safe pipe thread_safe_pipe = io_util.ThreadSafePipe(QUEUE_BUFFER_SIZE) #The read thread @@ -73,7 +70,7 @@ def start_transfer(read_file_handle, write_file_handle, data_size): def fetch_image(image, instance, **kwargs): - """Fetch an image for attaching to the newly created VM.""" + """ Fetch an image for attaching to the newly created VM """ #Depending upon the image service, make appropriate image service call if FLAGS.image_service == "nova.image.glance.GlanceImageService": func = _get_glance_image @@ -81,8 +78,6 @@ def fetch_image(image, instance, **kwargs): func = _get_s3_image elif FLAGS.image_service == "nova.image.local.LocalImageService": func = _get_local_image - elif FLAGS.image_service == "nova.FakeImageService": - func = _get_fake_image else: raise NotImplementedError(_("The Image Service %s is not implemented") % FLAGS.image_service) @@ -90,7 +85,7 @@ def fetch_image(image, instance, **kwargs): def upload_image(image, instance, **kwargs): - """Upload the newly snapshotted VM disk file.""" + """ Upload the newly snapshotted VM disk file. """ #Depending upon the image service, make appropriate image service call if FLAGS.image_service == "nova.image.glance.GlanceImageService": func = _put_glance_image @@ -98,8 +93,6 @@ def upload_image(image, instance, **kwargs): func = _put_s3_image elif FLAGS.image_service == "nova.image.local.LocalImageService": func = _put_local_image - elif FLAGS.image_service == "nova.FakeImageService": - func = _put_fake_image else: raise NotImplementedError(_("The Image Service %s is not implemented") % FLAGS.image_service) @@ -107,7 +100,7 @@ def upload_image(image, instance, **kwargs): def _get_glance_image(image, instance, **kwargs): - """Download image from the glance image server.""" + """ Download image from the glance image server. """ LOG.debug(_("Downloading image %s from glance image server") % image) read_file_handle = read_write_util.GlanceHTTPReadFile(FLAGS.glance_host, FLAGS.glance_port, @@ -125,38 +118,17 @@ def _get_glance_image(image, instance, **kwargs): def _get_s3_image(image, instance, **kwargs): - """Download image from the S3 image server.""" + """ Download image from the S3 image server. """ raise NotImplementedError def _get_local_image(image, instance, **kwargs): - """Download image from the local nova compute node.""" + """ Download image from the local nova compute node. """ raise NotImplementedError -def _get_fake_image(image, instance, **kwargs): - """ Download a fake image from the nova local file repository for testing - purposes. - """ - LOG.debug(_("Downloading image %s from fake image service") % image) - image = str(image) - file_path = os.path.join(TEST_IMAGE_PATH, image, image) - file_path = os.path.abspath(file_path) - read_file_handle = read_write_util.FakeFileRead(file_path) - file_size = read_file_handle.get_size() - write_file_handle = read_write_util.VMWareHTTPWriteFile( - kwargs.get("host"), - kwargs.get("data_center_name"), - kwargs.get("datastore_name"), - kwargs.get("cookies"), - kwargs.get("file_path"), - file_size) - start_transfer(read_file_handle, write_file_handle, file_size) - LOG.debug(_("Downloaded image %s from fake image service") % image) - - def _put_glance_image(image, instance, **kwargs): - """Upload the snapshotted vm disk file to Glance image server.""" + """ Upload the snapshotted vm disk file to Glance image server """ LOG.debug(_("Uploading image %s to the Glance image server") % image) read_file_handle = read_write_util.VmWareHTTPReadFile( kwargs.get("host"), @@ -178,48 +150,20 @@ def _put_glance_image(image, instance, **kwargs): def _put_local_image(image, instance, **kwargs): - """Upload the snapshotted vm disk file to the local nova compute node.""" + """ Upload the snapshotted vm disk file to the local nova compute node. """ raise NotImplementedError def _put_s3_image(image, instance, **kwargs): - """Upload the snapshotted vm disk file to S3 image server.""" + """ Upload the snapshotted vm disk file to S3 image server. """ raise NotImplementedError -def _put_fake_image(image, instance, **kwargs): - """ Upload a dummy vmdk from the ESX host to the local file repository of - the nova node for testing purposes. - """ - LOG.debug(_("Uploading image %s to the Fake Image Service") % image) - read_file_handle = read_write_util.VmWareHTTPReadFile( - kwargs.get("host"), - kwargs.get("data_center_name"), - kwargs.get("datastore_name"), - kwargs.get("cookies"), - kwargs.get("file_path")) - file_size = read_file_handle.get_size() - image = str(image) - image_dir_path = os.path.join(TEST_IMAGE_PATH, image) - if not os.path.exists(TEST_IMAGE_PATH): - os.mkdir(TEST_IMAGE_PATH) - os.mkdir(image_dir_path) - else: - if not os.path.exists(image_dir_path): - os.mkdir(image_dir_path) - file_path = os.path.join(image_dir_path, image) - file_path = os.path.abspath(file_path) - write_file_handle = read_write_util.FakeFileWrite(file_path) - start_transfer(read_file_handle, write_file_handle, file_size) - LOG.debug(_("Uploaded image %s to the Fake Image Service") % image) - - def get_vmdk_size_and_properties(image, instance): - """ - Get size of the vmdk file that is to be downloaded for attach in spawn. + """ Get size of the vmdk file that is to be downloaded for attach in spawn. Need this to create the dummy virtual disk for the meta-data file. The - geometry of the disk created depends on the size. - """ + geometry of the disk created depends on the size.""" + LOG.debug(_("Getting image size for the image %s") % image) if FLAGS.image_service == "nova.image.glance.GlanceImageService": read_file_handle = read_write_util.GlanceHTTPReadFile( @@ -230,15 +174,9 @@ def get_vmdk_size_and_properties(image, instance): raise NotImplementedError elif FLAGS.image_service == "nova.image.local.LocalImageService": raise NotImplementedError - elif FLAGS.image_service == "nova.FakeImageService": - image = str(image) - file_path = os.path.join(TEST_IMAGE_PATH, image, image) - file_path = os.path.abspath(file_path) - read_file_handle = read_write_util.FakeFileRead(file_path) size = read_file_handle.get_size() properties = read_file_handle.get_image_properties() read_file_handle.close() LOG.debug(_("Got image size of %(size)s for the image %(image)s") % - {'size': size, - 'image': image}) + locals()) return size, properties diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index 29748fe81..bd3ab4320 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -16,33 +16,30 @@ # under the License. """ -Connection class for VMware Infrastructure API in VMware ESX/ESXi platform - -Encapsulates the session management activties and acts as interface for VI API. -The connection class sets up a session with the ESX/ESXi compute provider host -and handles all the calls made to the host. +A connection to the VMware ESX platform. **Related Flags** -:vmwareapi_host_ip: IP of VMware ESX/ESXi compute provider host -:vmwareapi_host_username: ESX/ESXi server user to be used for API session -:vmwareapi_host_password: Password for the user "vmwareapi_host_username" -:vmwareapi_task_poll_interval: The interval used for polling of remote tasks -:vmwareapi_api_retry_count: Max number of retry attempts upon API failures - +:vmwareapi_host_ip: IPAddress of VMware ESX server. +:vmwareapi_host_username: Username for connection to VMware ESX Server. +:vmwareapi_host_password: Password for connection to VMware ESX Server. +:vmwareapi_task_poll_interval: The interval (seconds) used for polling of + remote tasks + (default: 1.0). +:vmwareapi_api_retry_count: The API retry count in case of failure such as + network failures (socket errors etc.) + (default: 10). """ -import logging import time -import urlparse from eventlet import event from nova import context from nova import db from nova import flags +from nova import log as logging from nova import utils - from nova.virt.vmwareapi import vim from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi.vmops import VMWareVMOps @@ -71,45 +68,34 @@ flags.DEFINE_float('vmwareapi_api_retry_count', 'The number of times we retry on failures, ' 'e.g., socket error, etc.' 'Used only if connection_type is vmwareapi') +flags.DEFINE_string('vmwareapi_vlan_interface', + 'vmnic0', + 'Physical ethernet adapter name for vlan networking') TIME_BETWEEN_API_CALL_RETRIES = 2.0 -class TaskState: - """Enumeration class for different states of task - 0 - Task completed successfully - 1 - Task is in queued state - 2 - Task is in running state - """ - - TASK_SUCCESS = 0 - TASK_QUEUED = 1 - TASK_RUNNING = 2 - - class Failure(Exception): """Base Exception class for handling task failures""" def __init__(self, details): - """Initializer""" self.details = details def __str__(self): - """The informal string representation of the object""" return str(self.details) def get_connection(_): - """Sets up the ESX host connection""" + """Sets up the ESX host connection.""" host_ip = FLAGS.vmwareapi_host_ip host_username = FLAGS.vmwareapi_host_username host_password = FLAGS.vmwareapi_host_password api_retry_count = FLAGS.vmwareapi_api_retry_count - if not host_ip or host_username is None or host_password is None: - raise Exception('Must specify vmwareapi_host_ip,' - 'vmwareapi_host_username ' - 'and vmwareapi_host_password to use' - 'connection_type=vmwareapi') + if not host_ip or host_username is None or host_password is None: + raise Exception(_("Must specify vmwareapi_host_ip," + "vmwareapi_host_username " + "and vmwareapi_host_password to use" + "connection_type=vmwareapi")) return VMWareESXConnection(host_ip, host_username, host_password, api_retry_count) @@ -119,7 +105,6 @@ class VMWareESXConnection(object): def __init__(self, host_ip, host_username, host_password, api_retry_count, scheme="https"): - """The Initializer""" session = VMWareAPISession(host_ip, host_username, host_password, api_retry_count, scheme=scheme) self._vmops = VMWareVMOps(session) @@ -191,22 +176,18 @@ class VMWareESXConnection(object): def get_console_pool_info(self, console_type): """Get info about the host on which the VM resides""" - esx_url = urlparse.urlparse(FLAGS.vmwareapi_host_ip) - return {'address': esx_url.netloc, - 'username': FLAGS.vmwareapi_host_password, - 'password': FLAGS.vmwareapi_host_password} - - def _create_dummy_vm_for_test(self, instance): - """Creates a dummy VM with default parameters for testing purpose""" - return self._vmops._create_dummy_vm_for_test(instance) + return {'address': FLAGS.vmwareapi_host_ip, + 'username': FLAGS.vmwareapi_host_username, + 'password': FLAGS.vmwareapi_host_password} class VMWareAPISession(object): - """Sets up a session with ESX host and handles all calls made to host""" + """Sets up a session with the ESX host and handles all + the calls made to the host + """ def __init__(self, host_ip, host_username, host_password, api_retry_count, scheme="https"): - """Set the connection credentials""" self._host_ip = host_ip self._host_username = host_username self._host_password = host_password @@ -216,15 +197,19 @@ class VMWareAPISession(object): self.vim = None self._create_session() + def _get_vim_object(self): + """Create the VIM Object instance""" + return vim.Vim(protocol=self._scheme, host=self._host_ip) + def _create_session(self): """Creates a session with the ESX host""" while True: try: # Login and setup the session with the ESX host for making # API calls - self.vim = vim.Vim(protocol=self._scheme, host=self._host_ip) + self.vim = self._get_vim_object() session = self.vim.Login( - self.vim.get_service_content().SessionManager, + self.vim.get_service_content().sessionManager, userName=self._host_username, password=self._host_password) # Terminate the earlier session, if possible ( For the sake of @@ -233,34 +218,40 @@ class VMWareAPISession(object): if self._session_id: try: self.vim.TerminateSession( - self.vim.get_service_content().SessionManager, + self.vim.get_service_content().sessionManager, sessionId=[self._session_id]) except Exception, excep: LOG.exception(excep) - self._session_id = session.Key + self._session_id = session.key return except Exception, excep: - LOG.info(_("In vmwareapi:_create_session, " + LOG.critical(_("In vmwareapi:_create_session, " "got this exception: %s") % excep) raise Exception(excep) def __del__(self): - """The Destructor. Logs-out the session.""" + """Logs-out the session.""" # Logout to avoid un-necessary increase in session count at the # ESX host try: - self.vim.Logout(self.vim.get_service_content().SessionManager) + self.vim.Logout(self.vim.get_service_content().sessionManager) except Exception: pass + def _is_vim_object(self, module): + """Check if the module is a VIM Object instance""" + return isinstance(module, vim.Vim) + def _call_method(self, module, method, *args, **kwargs): - """Calls a method within the module specified with args provided""" + """Calls a method within the module specified with + args provided + """ args = list(args) retry_count = 0 exc = None while True: try: - if not isinstance(module, vim.Vim): + if not self._is_vim_object(module): #If it is not the first try, then get the latest vim object if retry_count > 0: args = args[1:] @@ -295,8 +286,8 @@ class VMWareAPISession(object): break time.sleep(TIME_BETWEEN_API_CALL_RETRIES) - LOG.info(_("In vmwareapi:_call_method, " - "got this exception: ") % exc) + LOG.critical(_("In vmwareapi:_call_method, " + "got this exception: %s") % exc) raise Exception(exc) def _get_vim(self): @@ -306,8 +297,7 @@ class VMWareAPISession(object): return self.vim def _wait_for_task(self, instance_id, task_ref): - """ - Return a Deferred that will give the result of the given task. + """Return a Deferred that will give the result of the given task. The task is polled until it completes. """ done = event.Event() @@ -319,36 +309,30 @@ class VMWareAPISession(object): return ret_val def _poll_task(self, instance_id, task_ref, done): - """ - Poll the given task, and fires the given Deferred if we + """Poll the given task, and fires the given Deferred if we get a result. """ try: task_info = self._call_method(vim_util, "get_dynamic_property", task_ref, "Task", "info") - task_name = task_info.Name + task_name = task_info.name action = dict( instance_id=int(instance_id), action=task_name[0:255], error=None) - if task_info.State in [TaskState.TASK_QUEUED, - TaskState.TASK_RUNNING]: + if task_info.state in ['queued', 'running']: return - elif task_info.State == TaskState.TASK_SUCCESS: - LOG.info(_("Task [%(taskname)s] %(taskref)s status: success") % - {'taskname': task_name, - 'taskref': str(task_ref)}) - done.send(TaskState.TASK_SUCCESS) + elif task_info.state == 'success': + LOG.info(_("Task [%(task_name)s] %(task_ref)s " + "status: success") % locals()) + done.send("success") else: - error_info = str(task_info.Error.LocalizedMessage) + error_info = str(task_info.error.localizedMessage) action["error"] = error_info - LOG.info(_("Task [%(task_name)s] %(task_ref)s status: " - "error [%(error_info)s]") % - {'task_name': task_name, - 'task_ref': str(task_ref), - 'error_info': error_info}) + LOG.warn(_("Task [%(task_name)s] %(task_ref)s " + "status: error %(error_info)s") % locals()) done.send_exception(Exception(error_info)) db.instance_action_create(context.get_admin_context(), action) except Exception, excep: - LOG.info(_("In vmwareapi:_poll_task, Got this error %s") % excep) + LOG.warn(_("In vmwareapi:_poll_task, Got this error %s") % excep) done.send_exception(excep) -- cgit From 93b69176277217a3cfae738dd328e649081a370f Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Tue, 1 Mar 2011 13:26:31 -0600 Subject: Review feedback --- nova/virt/xenapi/vmops.py | 42 ++++++++++++++++++++++-------------------- 1 file changed, 22 insertions(+), 20 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a3379fa7f..1c58f529d 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -202,18 +202,19 @@ class VMOps(object): _('Instance not present %s') % instance_name) return vm - def _bootlock(self, vm, unlock=False): + def _acquire_bootlock(self, vm): """Prevent an instance from booting""" - if unlock: - self._session.call_xenapi( - "VM.remove_from_blocked_operations", - vm, - "start") - else: - self._session.call_xenapi( - "VM.set_blocked_operations", - vm, - {"start": ""}) + self._session.call_xenapi( + "VM.set_blocked_operations", + vm, + {"start": ""}) + + def _release_bootlock(self, vm): + """Allow an instance to boot""" + self._session.call_xenapi( + "VM.remove_from_blocked_operations", + vm, + "start") def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance @@ -338,7 +339,7 @@ class VMOps(object): raise RuntimeError(resp_dict['message']) return resp_dict['message'] - def _shutdown(self, instance, vm): + def _shutdown(self, instance, vm, hard=True): """Shutdown an instance""" state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: @@ -350,12 +351,13 @@ class VMOps(object): LOG.debug(_("Shutting down VM for Instance %(instance_id)s") % locals()) try: - try: - task = self._session.call_xenapi("Async.VM.clean_shutdown", vm) - self._session.wait_for_task(task, instance.id) - except self.XenAPI.Failure: + task = None + if hard: task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) - self._session.wait_for_task(task, instance.id) + else: + task = self._session.call_xenapi("Async.VM.clean_shutdown", vm) + + self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure, exc: LOG.exception(exc) @@ -501,7 +503,7 @@ class VMOps(object): vm = self._get_vm_opaque_ref(instance) self._shutdown(instance, vm) - self._bootlock(vm) + self._acquire_bootlock(vm) instance._rescue = True self.spawn(instance) @@ -533,7 +535,7 @@ class VMOps(object): for vbd_ref in vbds: vbd = self._session.get_xenapi().VBD.get_record(vbd_ref) - if vbd["userdevice"] == str(1): + if vbd["userdevice"] == "1": VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) @@ -551,7 +553,7 @@ class VMOps(object): task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm) self._session.wait_for_task(task2, instance.id) - self._bootlock(original_vm, unlock=True) + self._release_bootlock(original_vm) self._start(instance, original_vm) def get_info(self, instance): -- cgit From cdb1b16a6019fd68a7969666d754c4007607ae53 Mon Sep 17 00:00:00 2001 From: Cory Wright Date: Tue, 1 Mar 2011 23:18:37 +0000 Subject: * Added ability to launch XenServer instances with per-os vm-params. --- nova/virt/xenapi/vm_utils.py | 152 ++++++++++++++++++++++++++++++------------- nova/virt/xenapi/vmops.py | 17 ++--- 2 files changed, 113 insertions(+), 56 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 6d9aeb060..11f1fabe9 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -80,62 +80,80 @@ class VMHelper(HelperBase): """ @classmethod - def create_vm(cls, session, instance, kernel, ramdisk, pv_kernel=False): + def create_vm(cls, session, instance, kernel, ramdisk, use_pv_kernel=False): """Create a VM record. Returns a Deferred that gives the new VM reference. - the pv_kernel flag indicates whether the guest is HVM or PV + the use_pv_kernel flag indicates whether the guest is HVM or PV + + There are 3 scenarios: + + 1. Using paravirtualization, kernel passed in + + 2. Using paravirtualization, kernel within the image + + 3. Using hardware virtualization """ instance_type = instance_types.INSTANCE_TYPES[instance.instance_type] mem = str(long(instance_type['memory_mb']) * 1024 * 1024) vcpus = str(instance_type['vcpus']) rec = { - 'name_label': instance.name, - 'name_description': '', + 'actions_after_crash': 'destroy', + 'actions_after_reboot': 'restart', + 'actions_after_shutdown': 'destroy', + 'affinity': '', + 'blocked_operations': {}, + 'ha_always_run': False, + 'ha_restart_priority': '', + 'HVM_boot_params': {}, + 'HVM_boot_policy': '', 'is_a_template': False, - 'memory_static_min': '0', - 'memory_static_max': mem, 'memory_dynamic_min': mem, 'memory_dynamic_max': mem, - 'VCPUs_at_startup': vcpus, - 'VCPUs_max': vcpus, - 'VCPUs_params': {}, - 'actions_after_shutdown': 'destroy', - 'actions_after_reboot': 'restart', - 'actions_after_crash': 'destroy', - 'PV_bootloader': '', - 'PV_kernel': '', - 'PV_ramdisk': '', + 'memory_static_min': '0', + 'memory_static_max': mem, + 'memory_target': mem, + 'name_description': '', + 'name_label': instance.name, +# 'other_config': {'allowvssprovider': False}, + 'other_config': {}, + 'PCI_bus': '', + 'platform': {'acpi': 'true', 'apic': 'true', 'pae': 'true', + 'viridian': 'true', 'timeoffset': '0'}, 'PV_args': '', + 'PV_bootloader': '', 'PV_bootloader_args': '', + 'PV_kernel': '', 'PV_legacy_args': '', - 'HVM_boot_policy': '', - 'HVM_boot_params': {}, - 'platform': {}, - 'PCI_bus': '', + 'PV_ramdisk': '', 'recommendations': '', - 'affinity': '', + 'tags': [], 'user_version': '0', - 'other_config': {}, + 'VCPUs_at_startup': vcpus, + 'VCPUs_max': vcpus, + 'VCPUs_params': {}, + 'xenstore_data': {} } - #Complete VM configuration record according to the image type - #non-raw/raw with PV kernel/raw in HVM mode - if instance.kernel_id: - rec['PV_bootloader'] = '' - rec['PV_kernel'] = kernel - rec['PV_ramdisk'] = ramdisk - rec['PV_args'] = 'root=/dev/xvda1' - rec['PV_bootloader_args'] = '' - rec['PV_legacy_args'] = '' - else: - if pv_kernel: - rec['PV_args'] = 'noninteractive' - rec['PV_bootloader'] = 'pygrub' + + # Complete VM configuration record according to the image type + # non-raw/raw with PV kernel/raw in HVM mode + if use_pv_kernel: + rec['platform']['nx'] = 'false' + if instance.kernel_id: + # 1. Kernel explicitly passed in, use that + rec['PV_args'] = 'root=/dev/xvda1' + rec['PV_kernel'] = kernel + rec['PV_ramdisk'] = ramdisk else: - rec['HVM_boot_policy'] = 'BIOS order' - rec['HVM_boot_params'] = {'order': 'dc'} - rec['platform'] = {'acpi': 'true', 'apic': 'true', - 'pae': 'true', 'viridian': 'true'} + # 2. Use kernel within the image + rec['PV_args'] = 'clocksource=jiffies' + rec['PV_bootloader'] = 'pygrub' + else: + # 3. Using hardware virtualization + rec['platform']['nx'] = 'true' + rec['HVM_boot_params'] = {'order': 'dc'} + rec['HVM_boot_policy'] = 'BIOS order' + LOG.debug(_('Created VM %s...'), instance.name) vm_ref = session.call_xenapi('VM.create', rec) instance_name = instance.name @@ -497,17 +515,32 @@ class VMHelper(HelperBase): return uuid @classmethod - def lookup_image(cls, session, instance_id, vdi_ref): + def determine_is_pv(cls, session, instance_id, vdi_ref, disk_image_type, + os_type): """ - Determine if VDI is using a PV kernel + Determine whether the VM will use a paravirtualized kernel or if it + will use hardware virtualization. + + 1. Objectstore (any image type): + We use plugin to figure out whether the VDI uses PV + + 2. Glance (VHD): then we use `os_type`, raise if not set + + 3. Glance (DISK_RAW): use Pygrub to figure out if pv kernel is + available + + 4. Glance (DISK): pv is assumed """ if FLAGS.xenapi_image_service == 'glance': - return cls._lookup_image_glance(session, vdi_ref) + # 2, 3, 4: Glance + return cls._determine_is_pv_glance( + session, vdi_ref, disk_image_type, os_type) else: - return cls._lookup_image_objectstore(session, instance_id, vdi_ref) + # 1. Objecstore + return cls._determine_is_pv_objectstore(session, instance_id, vdi_ref) @classmethod - def _lookup_image_objectstore(cls, session, instance_id, vdi_ref): + def _determine_is_pv_objectstore(cls, session, instance_id, vdi_ref): LOG.debug(_("Looking up vdi %s for PV kernel"), vdi_ref) fn = "is_vdi_pv" args = {} @@ -523,9 +556,38 @@ class VMHelper(HelperBase): return pv @classmethod - def _lookup_image_glance(cls, session, vdi_ref): + def _determine_is_pv_glance(cls, session, vdi_ref, disk_image_type, + os_type): + """ + For a Glance image, determine if we need paravirtualization. + + The relevant scenarios are: + 2. Glance (VHD): then we use `os_type`, raise if not set + + 3. Glance (DISK_RAW): use Pygrub to figure out if pv kernel is + available + + 4. Glance (DISK): pv is assumed + """ + LOG.debug(_("Looking up vdi %s for PV kernel"), vdi_ref) - return with_vdi_attached_here(session, vdi_ref, True, _is_vdi_pv) + if disk_image_type == ImageType.DISK_VHD: + # 2. VHD + if os_type == 'windows': + is_pv = False + else: + is_pv = True + elif disk_image_type == ImageType.DISK_RAW: + # 3. RAW + is_pv = with_vdi_attached_here(session, vdi_ref, True, _is_vdi_pv) + elif disk_image_type == ImageType.DISK: + # 4. Disk + is_pv = True + else: + raise exception.Error(_("Unknown image format %(disk_image_type)s") + % locals()) + + return is_pv @classmethod def lookup(cls, session, i): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index bc39aa140..abc1fb699 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -87,15 +87,7 @@ class VMOps(object): vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - pv_kernel = False - if disk_image_type == ImageType.DISK_RAW: - #Have a look at the VDI and see if it has a PV kernel - pv_kernel = VMHelper.lookup_image(self._session, instance.id, - vdi_ref) - elif disk_image_type == ImageType.DISK_VHD: - # TODO(sirp): Assuming PV for now; this will need to be - # configurable as Windows will use HVM. - pv_kernel = True + os_type = instance.get('os_type', 'linux') kernel = None if instance.kernel_id: @@ -107,8 +99,11 @@ class VMOps(object): ramdisk = VMHelper.fetch_image(self._session, instance.id, instance.ramdisk_id, user, project, ImageType.KERNEL_RAMDISK) - vm_ref = VMHelper.create_vm(self._session, - instance, kernel, ramdisk, pv_kernel) + use_pv_kernel = VMHelper.determine_is_pv( + self._session, instance.id, vdi_ref, disk_image_type, os_type) + vm_ref = VMHelper.create_vm(self._session, instance, kernel, ramdisk, + use_pv_kernel) + VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) # inject_network_info and create vifs -- cgit From 6321c5047c082bba8edf10a660fdb6a56430cc44 Mon Sep 17 00:00:00 2001 From: Cory Wright Date: Wed, 2 Mar 2011 00:19:02 +0000 Subject: * Added first cut of migration for os_type on instances table * Track os_type when taking snapshots --- nova/virt/xenapi/vm_utils.py | 9 ++++++--- nova/virt/xenapi/vmops.py | 4 ++-- 2 files changed, 8 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 11f1fabe9..9c0bb5579 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -303,7 +303,7 @@ class VMHelper(HelperBase): return template_vm_ref, template_vdi_uuids @classmethod - def upload_image(cls, session, instance_id, vdi_uuids, image_id): + def upload_image(cls, session, instance, vdi_uuids, image_id): """ Requests that the Glance plugin bundle the specified VDIs and push them into Glance using the specified human-friendly name. """ @@ -312,15 +312,18 @@ class VMHelper(HelperBase): logging.debug(_("Asking xapi to upload %(vdi_uuids)s as" " ID %(image_id)s") % locals()) + # TODO(dubs): os_type is currently defaulting to linux, we actually + # want to make this a NOT NULL column and require it to be specified. params = {'vdi_uuids': vdi_uuids, 'image_id': image_id, 'glance_host': FLAGS.glance_host, 'glance_port': FLAGS.glance_port, - 'sr_path': get_sr_path(session)} + 'sr_path': get_sr_path(session), + 'os_type': instance.get('os_type', 'linux')} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'upload_vhd', kwargs) - session.wait_for_task(instance_id, task) + session.wait_for_task(instance.id, task) @classmethod def fetch_image(cls, session, instance_id, image, user, project, diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index abc1fb699..1edf39c5b 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -238,11 +238,11 @@ class VMOps(object): try: # call plugin to ship snapshot off to glance VMHelper.upload_image( - self._session, instance.id, template_vdi_uuids, image_id) + self._session, instance, template_vdi_uuids, image_id) finally: self._destroy(instance, template_vm_ref, shutdown=False, destroy_kernel_ramdisk=False) - + logging.debug(_("Finished snapshot and upload for VM %s"), instance) def reboot(self, instance): -- cgit From df0a4d66f7059db94e1de365fed8b8d244e16534 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Tue, 1 Mar 2011 17:12:47 -0800 Subject: Changed ra_server to gateway_v6 and removed addressv6 column from fixed_ips db table --- nova/virt/interfaces.template | 6 +++--- nova/virt/libvirt.xml.template | 4 ++-- nova/virt/libvirt_conn.py | 40 ++++++++++++++++++++-------------------- 3 files changed, 25 insertions(+), 25 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/interfaces.template b/nova/virt/interfaces.template index 1db745f9f..3b34e54f4 100644 --- a/nova/virt/interfaces.template +++ b/nova/virt/interfaces.template @@ -16,8 +16,8 @@ iface eth0 inet static #if $use_ipv6 iface eth0 inet6 static - address ${addressv6} - netmask ${netmaskv6} - gateway ${gatewayv6} + address ${address_v6} + netmask ${netmask_v6} + gateway ${gateway_v6} #end if diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 88bfbc668..ef2d2cd6b 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -79,8 +79,8 @@ #if $getVar('extra_params', False) ${extra_params} #end if -#if $getVar('ra_server', False) - +#if $getVar('gateway_v6', False) + #end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index b7712f76e..38fa2338e 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -631,21 +631,21 @@ class LibvirtConnection(object): admin_context = context.get_admin_context() address = db.instance_get_fixed_address(admin_context, inst['id']) - addressv6 = db.instance_get_fixed_address_v6(admin_context, + address_v6 = db.instance_get_fixed_address_v6(admin_context, inst['id']) - ra_server = network_ref['ra_server'] - if not ra_server: - ra_server = "fd00::" + gateway_v6 = network_ref['gateway_v6'] + if not gateway_v6: + gateway_v6 = "fd00::" interfaces_info = {'address': address, 'netmask': network_ref['netmask'], 'gateway': network_ref['gateway'], 'broadcast': network_ref['broadcast'], 'dns': network_ref['dns'], - 'ra_server': ra_server, - 'addressv6': addressv6, - 'gatewayv6': network_ref['gatewayv6'], - 'netmaskv6': network_ref['netmaskv6'], + 'gateway_v6': gateway_v6, + 'address_v6': address_v6, + 'gateway_v6': network_ref['gateway_v6'], + 'netmask_v6': network_ref['netmask_v6'], 'use_ipv6': FLAGS.use_ipv6} net = str(Template(self.interfaces_xml, @@ -683,7 +683,7 @@ class LibvirtConnection(object): instance['id']) # Assume that the gateway also acts as the dhcp server. dhcp_server = network['gateway'] - ra_server = network['ra_server'] + gateway_v6 = network['gateway_v6'] if FLAGS.allow_project_net_traffic: if FLAGS.use_ipv6: @@ -728,8 +728,8 @@ class LibvirtConnection(object): 'local': instance_type['local_gb'], 'driver_type': driver_type} - if ra_server: - xml_info['ra_server'] = ra_server + "/128" + if gateway_v6: + xml_info['gateway_v6'] = gateway_v6 + "/128" if not rescue: if instance['kernel_id']: xml_info['kernel'] = xml_info['basepath'] + "/kernel" @@ -921,10 +921,10 @@ class FirewallDriver(object): """ raise NotImplementedError() - def _ra_server_for_instance(self, instance): + def _gateway_v6_for_instance(self, instance): network = db.network_get_by_instance(context.get_admin_context(), instance['id']) - return network['ra_server'] + return network['gateway_v6'] class NWFilterFirewall(FirewallDriver): @@ -1140,8 +1140,8 @@ class NWFilterFirewall(FirewallDriver): 'nova-base-ipv6', 'nova-allow-dhcp-server'] if FLAGS.use_ipv6: - ra_server = self._ra_server_for_instance(instance) - if ra_server: + gateway_v6 = self._gateway_v6_for_instance(instance) + if gateway_v6: instance_secgroup_filter_children += ['nova-allow-ra-server'] ctxt = context.get_admin_context() @@ -1328,10 +1328,10 @@ class IptablesFirewallDriver(FirewallDriver): our_rules += ['-A %s -s %s -j ACCEPT' % (chain_name, cidr)] elif(ip_version == 6): # Allow RA responses - ra_server = self._ra_server_for_instance(instance) - if ra_server: + gateway_v6 = self._gateway_v6_for_instance(instance) + if gateway_v6: our_rules += ['-A %s -s %s -p icmpv6 -j ACCEPT' % - (chain_name, ra_server + "/128")] + (chain_name, gateway_v6 + "/128")] #Allow project network traffic if (FLAGS.allow_project_net_traffic): cidrv6 = self._project_cidrv6_for_instance(instance) @@ -1427,10 +1427,10 @@ class IptablesFirewallDriver(FirewallDriver): instance['id']) return network['gateway'] - def _ra_server_for_instance(self, instance): + def _gateway_v6_for_instance(self, instance): network = db.network_get_by_instance(context.get_admin_context(), instance['id']) - return network['ra_server'] + return network['gateway_v6'] def _project_cidr_for_instance(self, instance): network = db.network_get_by_instance(context.get_admin_context(), -- cgit From 7825b7ce81dec97e997d296c3e30b5d143948abc Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Wed, 2 Mar 2011 01:21:54 -0800 Subject: initial commit of vnc support --- nova/virt/libvirt.xml.template | 1 + nova/virt/libvirt_conn.py | 17 +++++++++++++++++ 2 files changed, 18 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 88bfbc668..7b4c23211 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -101,5 +101,6 @@ + diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4e0fd106f..4fca84639 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -511,6 +511,23 @@ class LibvirtConnection(object): subprocess.Popen(cmd, shell=True) return {'token': token, 'host': host, 'port': port} + @exception.wrap_exception + def get_vnc_console(self, instance): + def get_vnc_port_for_instance(instance_name): + virt_dom = self._conn.lookupByName(instance_name) + xml = virt_dom.XMLDesc(0) + dom = minidom.parseString(xml) + + for graphic in dom.getElementsByTagName('graphics'): + if graphic.getAttribute('type') == 'vnc': + return graphic.getAttribute('port') + + port = get_vnc_port_for_instance(instance['name']) + token = str(uuid.uuid4()) + host = instance['host'] + + return {'token': token, 'host': host, 'port': port} + def _cache_image(self, fn, target, fname, cow=False, *args, **kwargs): """Wrapper for a method that creates an image that caches the image. -- cgit From e0f1490e481e5b3e0e28b25049cc69eb905b74d6 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 2 Mar 2011 09:50:44 +0000 Subject: Removed excess TODO comments and debug line --- nova/virt/xenapi/vmops.py | 2 -- 1 file changed, 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a2f3a8f09..ec620f918 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -111,7 +111,6 @@ class VMOps(object): VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True) # Alter the image before VM start for, e.g. network injection - #TODO(salvatore-orlando): do this only if flag is true if FLAGS.xenapi_inject_image: VMHelper.preconfigure_instance(self._session, instance, vdi_ref) @@ -493,7 +492,6 @@ class VMOps(object): 'ips': [ip_dict(ip) for ip in network_IPs]} self.write_to_param_xenstore(vm_opaque_ref, {location: mapping}) try: - logging.debug("About to run write_to_xenstore") self.write_to_xenstore(vm_opaque_ref, location, mapping['location']) except KeyError: -- cgit From 97563d650a08e7f2d1aa1f08237219291d821e39 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 2 Mar 2011 10:43:45 +0000 Subject: Changed _get_vm_opaqueref removing test-specific code paths. --- nova/virt/xenapi/vmops.py | 30 +++++++++--------------------- 1 file changed, 9 insertions(+), 21 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ec620f918..450a06315 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -51,6 +51,7 @@ class VMOps(object): def __init__(self, session): self.XenAPI = session.get_imported_xenapi() self._session = session + self.known_vm_refs = [] VMHelper.XenAPI = self.XenAPI def list_instances(self): @@ -176,29 +177,16 @@ class VMOps(object): a vm name or a vm instance, and want a vm instance in return. """ vm = None - try: - if instance_or_vm.startswith("OpaqueRef:"): - # Got passed an opaque ref; return it + if instance_or_vm in self.known_vm_refs: return instance_or_vm - else: - # Must be the instance name - instance_name = instance_or_vm - except (AttributeError, KeyError): - # - # Note the the KeyError will only happen with fakes.py - # Not a string; must be an ID or a vm instance - if isinstance(instance_or_vm, (int, long)): - ctx = context.get_admin_context() - instance_obj = db.instance_get(ctx, instance_or_vm) - instance_name = instance_obj.name - else: - instance_name = instance_or_vm.name - #fake xenapi does not use OpaqueRef as a prefix - #when running tests we will always end up here + instance_name = instance_or_vm + #if instance_or_vm is not a string; + #must be an ID or a vm instance + if not isinstance(instance_or_vm, str): + instance_name = instance_or_vm.name vm = VMHelper.lookup(self._session, instance_name) + self.known_vm_refs.append(vm) if vm is None: - if FLAGS.xenapi_connection_url == 'test_url': - return instance_or_vm raise exception.NotFound( _('Instance not present %s') % instance_name) return vm @@ -482,7 +470,7 @@ class VMOps(object): mac_id = instance.mac_address.replace(':', '') location = 'vm-data/networking/%s' % mac_id - #TODO(salvatore-orlando): key for broadcast address + #salvatore-orlando: key for broadcast address #provisionally set to 'broadcast' mapping = {'label': network['label'], 'gateway': network['gateway'], -- cgit From 6d62f387e39b42821f8a8f6ca560dd47b3bb9c7e Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 2 Mar 2011 15:42:21 -0600 Subject: Inject IPv6 data into XenStore for instance --- nova/virt/xenapi/vmops.py | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index bc39aa140..094b41588 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -514,18 +514,30 @@ class VMOps(object): network_IPs = [ip for ip in IPs if ip.network_id == network.id] def ip_dict(ip): - return {'netmask': network['netmask'], - 'enabled': '1', - 'ip': ip.address} + return { + "ip": ip.address, + "netmask": network["netmask"], + "enabled": "1"} + + def ip6_dict(ip6): + return { + "ip": ip6.addressV6, + "netmask": ip6.netmaskV6, + "gateway": ip6.gatewayV6, + "enabled": "1"} mac_id = instance.mac_address.replace(':', '') location = 'vm-data/networking/%s' % mac_id - mapping = {'label': network['label'], - 'gateway': network['gateway'], - 'mac': instance.mac_address, - 'dns': [network['dns']], - 'ips': [ip_dict(ip) for ip in network_IPs]} + mapping = { + 'label': network['label'], + 'gateway': network['gateway'], + 'mac': instance.mac_address, + 'dns': [network['dns']], + 'ips': [ip_dict(ip) for ip in network_IPs], + 'ip6s': [ip6_dict(ip) for ip in network_IPs]} + self.write_to_param_xenstore(vm_opaque_ref, {location: mapping}) + try: self.write_to_xenstore(vm_opaque_ref, location, mapping['location']) -- cgit From 953fe68ce9b27322003200c464c121464761d1e2 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 2 Mar 2011 15:46:50 -0600 Subject: merge fixes --- nova/virt/xenapi/vm_utils.py | 4 ++-- nova/virt/xenapi/vmops.py | 48 ++++++++++++++++++++------------------------ 2 files changed, 24 insertions(+), 28 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index eea9bb0b9..3ee963fa7 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -310,8 +310,7 @@ class VMHelper(HelperBase): def get_sr_path(cls, session, sr_label='slices'): """ Finds the SR and then coerces it into a path on the dom0 file system """ - # TODO(mdietz): replace this with the flag once unified-images merges - return '/var/run/sr-mount/%s' % cls.get_sr(session, sr_label) + return FLAGS.xenapi_sr_base_path + cls.get_sr(session, sr_label) @classmethod def upload_image(cls, session, instance_id, vdi_uuids, image_id): @@ -649,6 +648,7 @@ class VMHelper(HelperBase): @classmethod def scan_default_sr(cls, session): """Looks for the system default SR and triggers a re-scan""" + #FIXME(sirp/mdietz): refactor scan_default_sr in there sr_ref = cls.get_sr(session) session.call_xenapi('SR.scan', sr_ref) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 5157f18f1..b54084842 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -105,7 +105,7 @@ class VMOps(object): vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', disk) if disk_image_type == ImageType.DISK_RAW: - #Have a look at the VDI and see if it has a PV kernel + # Have a look at the VDI and see if it has a PV kernel pv_kernel = VMHelper.lookup_image(self._session, instance.id, vdi_ref) elif disk_image_type == ImageType.DISK_VHD: @@ -113,7 +113,6 @@ class VMOps(object): # configurable as Windows will use HVM. pv_kernel = True - #Have a look at the VDI and see if it has a PV kernel if instance.kernel_id: kernel = VMHelper.fetch_image(self._session, instance.id, instance.kernel_id, user, project, ImageType.KERNEL_RAMDISK) @@ -240,29 +239,20 @@ class VMOps(object): that will bundle the VHDs together and then push the bundle into Glance. """ - - with self._get_snapshot(instance) as snapshot: + template_vm_ref = None + try: + template_vm_ref, template_vdi_uuids = self._get_snapshot(instance) # call plugin to ship snapshot off to glance VMHelper.upload_image( - self._session, instance.id, snapshot.vdi_uuids, image_id) + self._session, instance.id, template_vdi_uuids, image_id) + finally: + if template_vm_ref: + self.virt._destroy(self.instance, template_vm_ref, shutdown=False, + destroy_kernel_ramdisk=False) logging.debug(_("Finished snapshot and upload for VM %s"), instance) def _get_snapshot(self, instance): - class Snapshot(object): - def __init__(self, virt, instance, vm_ref, vdis): - self.instance = instance - self.vdi_uuids = vdis - self.virt = virt - self.vm_ref = vm_ref - - def __enter__(self): - return self - - def __exit__(self, type, value, traceback): - self.virt._destroy(self.instance, self.vm_ref, shutdown=False, - destroy_kernel_ramdisk=False) - #TODO(sirp): Add quiesce and VSS locking support when Windows support # is added @@ -273,8 +263,7 @@ class VMOps(object): try: template_vm_ref, template_vdi_uuids = VMHelper.create_snapshot( self._session, instance.id, vm_ref, label) - return Snapshot(self, instance, template_vm_ref, - template_vdi_uuids) + return template_vm_ref, template_vdi_uuids except self.XenAPI.Failure, exc: logging.error(_("Unable to Snapshot %(vm_ref)s: %(exc)s") % locals()) @@ -294,9 +283,11 @@ class VMOps(object): # from the snapshot creation base_copy_uuid = cow_uuid = None - with self._get_snapshot(instance) as snapshot: + template_vdi_uuids = template_vm_ref = None + try: # transfer the base copy - base_copy_uuid = snapshot.vdi_uuids[1] + template_vm_ref, template_vdi_uuids = self._get_snapshot(instance) + base_copy_uuid = template_vdi_uuids[1] vdi_ref, vm_vdi_rec = \ VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) cow_uuid = vm_vdi_rec['uuid'] @@ -304,7 +295,7 @@ class VMOps(object): params = {'host': dest, 'vdi_uuid': base_copy_uuid, 'instance_id': instance.id, - 'sr_path': VMHelper.get_sr_path(self._session), } + 'sr_path': VMHelper.get_sr_path(self._session)} task = self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) @@ -322,6 +313,11 @@ class VMOps(object): {'params': pickle.dumps(params)}) self._session.wait_for_task(instance.id, task) + finally: + if template_vm_ref: + self.virt._destroy(self.instance, template_vm_ref, shutdown=False, + destroy_kernel_ramdisk=False) + # TODO(mdietz): we could also consider renaming these to something # sensible so we don't need to blindly pass around dictionaries return {'base_copy': base_copy_uuid, 'cow': cow_uuid} @@ -332,9 +328,9 @@ class VMOps(object): new_cow_uuid = str(uuid.uuid4()) params = {'instance_id': instance.id, 'old_base_copy_uuid': disk_info['base_copy'], - 'old_cow_uuid': disk_info['cow'], + 'old_cow_uuid': disk_info['cow'], 'new_base_copy_uuid': new_base_copy_uuid, - 'new_cow_uuid': new_cow_uuid, + 'new_cow_uuid': new_cow_uuid, 'sr_path': VMHelper.get_sr_path(self._session), } task = self._session.async_call_plugin('migration', -- cgit From e34e9dd982870915f8c4dbf84a08bece42b0c592 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 2 Mar 2011 17:09:50 -0600 Subject: Updated docstrings --- nova/virt/xenapi/vmops.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 1c58f529d..10d5c0160 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -495,7 +495,12 @@ class VMOps(object): self._wait_with_callback(instance.id, task, callback) def rescue(self, instance, callback): - """Rescue the specified instance""" + """Rescue the specified instance + - shutdown the instance VM + - set 'bootlock' to prevent the instance from starting in rescue + - spawn a rescue VM (the vm name-label will be instance-N-rescue) + + """ rescue_vm = VMHelper.lookup(self._session, instance.name + "-rescue") if rescue_vm: raise RuntimeError(_( @@ -521,7 +526,12 @@ class VMOps(object): self._session.call_xenapi("Async.VBD.plug", vbd_ref) def unrescue(self, instance, callback): - """Unrescue the specified instance""" + """Unrescue the specified instance + - unplug the instance VM's disk from the rescue VM + - teardown the rescue VM + - release the bootlock to allow the instance VM to start + + """ rescue_vm = VMHelper.lookup(self._session, instance.name + "-rescue") if not rescue_vm: -- cgit From f7645bc2fb46ab7649faf12c794834d94839e4d2 Mon Sep 17 00:00:00 2001 From: Thierry Carrez Date: Thu, 3 Mar 2011 13:55:01 +0100 Subject: Fix regression in the way libvirt_conn gets its instance_types --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 8a83e657f..9f7315c17 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -607,7 +607,7 @@ class LibvirtConnection(object): user=user, project=project, size=size) - type_data = instance_types.get_instance_type([inst['instance_type']]) + type_data = instance_types.get_instance_type(inst['instance_type']) if type_data['local_gb']: self._cache_image(fn=self._create_local, -- cgit From 693e4335dbef72317147abd70bdaa10e0d174020 Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Thu, 3 Mar 2011 22:54:11 +0900 Subject: Fixed based on reviewer's comments. Main changes are below. 1. Rename nova.compute.manager.ComputeManager.mktmpfile for better naming. 2. Several tests code in tests/test_virt.py are removed. Because it only works in libvirt environment. Only db-related testcode remains. --- nova/virt/libvirt_conn.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 75e4f0a53..70fdcc453 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -891,8 +891,8 @@ class LibvirtConnection(object): """ total = 0 - for i in self._conn.listDomainsID(): - dom = self._conn.lookupByID(i) + for dom_id in self._conn.listDomainsID(): + dom = self._conn.lookupByID(dom_id) total += len(dom.vcpus()[1]) return total @@ -1048,7 +1048,7 @@ class LibvirtConnection(object): 'cpu_info': self.get_cpu_info()} compute_service_ref = service_ref['compute_service'] - if len(compute_service_ref) == 0: + if not compute_service_ref: LOG.info(_('Compute_service record is created for %s ') % host) dic['service_id'] = service_ref['id'] db.compute_service_create(ctxt, dic) @@ -1124,7 +1124,7 @@ class LibvirtConnection(object): # wait for completion timeout_count = range(FLAGS.live_migration_retry_count) - while len(timeout_count) != 0: + while not timeout_count: try: filter_name = 'nova-instance-%s' % instance_ref.name self._conn.nwfilterLookupByName(filter_name) @@ -1198,7 +1198,7 @@ class LibvirtConnection(object): None, FLAGS.live_migration_bandwidth) - except Exception, e: + except Exception: recover_method(ctxt, instance_ref) raise -- cgit From 137a4946785b9460aadb9fe40f2b0e18bd7f6063 Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Fri, 4 Mar 2011 01:09:21 +0900 Subject: Merged to trunk rev 757. Main changes are below. 1. Rename db table ComputeService -> ComputeNode 2. nova-manage option instance_type is reserved and we cannot use option instance, so change instance -> vm. --- nova/virt/libvirt_conn.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index b9abf1890..71ca508b0 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1021,7 +1021,7 @@ class LibvirtConnection(object): self.firewall_driver.refresh_security_group_members(security_group_id) def update_available_resource(self, ctxt, host): - """Updates compute manager resource info on ComputeService table. + """Updates compute manager resource info on ComputeNode table. This method is called when nova-coompute launches, and whenever admin executes "nova-manage service update_resource". @@ -1049,14 +1049,14 @@ class LibvirtConnection(object): 'hypervisor_version': self.get_hypervisor_version(), 'cpu_info': self.get_cpu_info()} - compute_service_ref = service_ref['compute_service'] - if not compute_service_ref: + compute_node_ref = service_ref['compute_node'] + if not compute_node_ref: LOG.info(_('Compute_service record is created for %s ') % host) dic['service_id'] = service_ref['id'] - db.compute_service_create(ctxt, dic) + db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record is updated for %s ') % host) - db.compute_service_update(ctxt, compute_service_ref[0]['id'], dic) + db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic) def compare_cpu(self, cpu_info): """Checks the host cpu is compatible to a cpu given by xml. -- cgit From abd5779068f3b979fc79dec7a68549999c58092d Mon Sep 17 00:00:00 2001 From: Mark Washenberger Date: Fri, 4 Mar 2011 01:36:29 -0500 Subject: remove ensure_b64_encoding --- nova/virt/xenapi/vmops.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 9ac83efb0..89d58a664 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -19,6 +19,7 @@ Management class for VM-related functions (spawn, reboot, etc). """ +import base64 import json import M2Crypto import os @@ -313,17 +314,16 @@ class VMOps(object): task = self._session.call_xenapi("Async.VM.start", vm, False, False) self._session.wait_for_task(task, instance.id) - def inject_file(self, instance, b64_path, b64_contents): + def inject_file(self, instance, path, contents): """Write a file to the VM instance. The path to which it is to be written and the contents of the file need to be supplied; both should be base64-encoded to prevent errors with non-ASCII characters being transmitted. If the agent does not support file injection, or the user has disabled it, a NotImplementedError will be raised. """ - # Files/paths *should* be base64-encoded at this point, but - # double-check to make sure. - b64_path = utils.ensure_b64_encoding(b64_path) - b64_contents = utils.ensure_b64_encoding(b64_contents) + # Files/paths must be base64-encoded for transmission to agent + b64_path = base64.b64encode(path) + b64_contents = base64.b64encode(contents) # Need to uniquely identify this request. transaction_id = str(uuid.uuid4()) -- cgit From cb30c80c922a09ccca18645670ea5b1cdc70f1f2 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Fri, 4 Mar 2011 12:31:59 +0000 Subject: fixed wrong local variable name in vmops --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a7838dbba..417f40da8 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -519,7 +519,7 @@ class VMOps(object): NetworkHelper.find_network_with_name_label(self._session, bridge) if network_ref: - VMHelper.create_vif(self._session, vm_ref, + VMHelper.create_vif(self._session, vm_opaque_ref, network_ref, instance.mac_address) -- cgit From 1f0df07baac52379b122a9928200305dd9d2151f Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Sat, 5 Mar 2011 00:57:08 +0900 Subject: Fixed based on reviewer's comment. Main changes are below. 1. get_vcpu_total()/get_memory_mb()/get_memory_mb_used() is changed for users who used non-linux environment. 2. test code added to test_virt. --- nova/virt/libvirt_conn.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 71ca508b0..627a12a1c 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -36,8 +36,10 @@ Supports KVM, QEMU, UML, and XEN. """ +import multiprocessing import os import shutil +import sys import random import subprocess import time @@ -858,7 +860,7 @@ class LibvirtConnection(object): """ - return open('/proc/cpuinfo').read().count('processor') + return multiprocessing.cpu_count() def get_memory_mb_total(self): """Get the total memory size(MB) of physical computer. @@ -867,6 +869,9 @@ class LibvirtConnection(object): """ + if sys.platform.upper() != 'LINUX2': + return 0 + meminfo = open('/proc/meminfo').read().split() idx = meminfo.index('MemTotal:') # transforming kb to mb. @@ -905,6 +910,9 @@ class LibvirtConnection(object): """ + if sys.platform.upper() != 'LINUX2': + return 0 + m = open('/proc/meminfo').read().split() idx1 = m.index('MemFree:') idx2 = m.index('Buffers:') @@ -1126,7 +1134,7 @@ class LibvirtConnection(object): # wait for completion timeout_count = range(FLAGS.live_migration_retry_count) - while not timeout_count: + while timeout_count: try: filter_name = 'nova-instance-%s' % instance_ref.name self._conn.nwfilterLookupByName(filter_name) -- cgit From 1d8914fc752f7182f942cdd40f2ba18baedeed0c Mon Sep 17 00:00:00 2001 From: Cerberus Date: Fri, 4 Mar 2011 11:19:35 -0600 Subject: More fixes --- nova/virt/xenapi/vm_utils.py | 16 ++++++++-------- nova/virt/xenapi/vmops.py | 11 ++++++----- 2 files changed, 14 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index ca2d634f1..eff207a51 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -270,8 +270,8 @@ class VMHelper(HelperBase): @classmethod def create_snapshot(cls, session, instance_id, vm_ref, label): - """ Creates Snapshot (Template) VM, Snapshot VBD, Snapshot VDI, - Snapshot VHD """ + """Creates Snapshot (Template) VM, Snapshot VBD, Snapshot VDI, + Snapshot VHD""" #TODO(sirp): Add quiesce and VSS locking support when Windows support # is added LOG.debug(_("Snapshotting VM %(vm_ref)s with label '%(label)s'...") @@ -284,7 +284,7 @@ class VMHelper(HelperBase): original_parent_uuid = get_vhd_parent_uuid(session, vm_vdi_ref) task = session.call_xenapi('Async.VM.snapshot', vm_ref, label) - template_vm_ref = session.wait_for_task(instance_id, task) + template_vm_ref = session.wait_for_task(task, instance_id) template_vdi_rec = cls.get_vdi_for_vm_safely(session, template_vm_ref)[1] template_vdi_uuid = template_vdi_rec["uuid"] @@ -302,14 +302,14 @@ class VMHelper(HelperBase): @classmethod def get_sr(cls, session, sr_label='slices'): - """ Finds the SR named by the given name label and returns - the UUID """ + """Finds the SR named by the given name label and returns + the UUID""" return session.call_xenapi('SR.get_by_name_label', sr_label)[0] @classmethod def get_sr_path(cls, session, sr_label='slices'): - """ Finds the SR and then coerces it into a path on the dom0 file - system """ + """Finds the SR and then coerces it into a path on the dom0 file + system""" return FLAGS.xenapi_sr_base_path + cls.get_sr(session, sr_label) @classmethod @@ -643,7 +643,7 @@ class VMHelper(HelperBase): if sr_ref: LOG.debug(_("Re-scanning SR %s"), sr_ref) task = session.call_xenapi('Async.SR.scan', sr_ref) - session.wait_for_task(instance_id, task) + session.wait_for_task(task, instance_id) @classmethod def scan_default_sr(cls, session): diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 60ce51f4a..01bfa2dc5 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -233,7 +233,7 @@ class VMOps(object): "start") def snapshot(self, instance, image_id): - """ Create snapshot from a running VM instance + """Create snapshot from a running VM instance :param instance: instance to be snapshotted :param image_id: id of image to upload to @@ -285,7 +285,7 @@ class VMOps(object): return def migrate_disk_and_power_off(self, instance, dest): - """ Copies a VHD from one host machine to another + """Copies a VHD from one host machine to another :param instance: the instance that owns the VHD in question :param dest: the destination host machine @@ -314,7 +314,7 @@ class VMOps(object): task = self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) # Now power down the instance and transfer the COW VHD self._shutdown(instance, vm_ref, method='clean') @@ -326,7 +326,7 @@ class VMOps(object): task = self._session.async_call_plugin('migration', 'transfer_vhd', {'params': pickle.dumps(params)}) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) finally: if template_vm_ref: @@ -338,6 +338,7 @@ class VMOps(object): return {'base_copy': base_copy_uuid, 'cow': cow_uuid} def attach_disk(self, instance, disk_info): + """Links the base copy VHD to the COW via the XAPI plugin""" vm_ref = VMHelper.lookup(self._session, instance.name) new_base_copy_uuid = str(uuid.uuid4()) new_cow_uuid = str(uuid.uuid4()) @@ -350,7 +351,7 @@ class VMOps(object): task = self._session.async_call_plugin('migration', 'move_vhds_into_sr', {'params': pickle.dumps(params)}) - self._session.wait_for_task(instance.id, task) + self._session.wait_for_task(task, instance.id) # Now we rescan the SR so we find the VHDs VMHelper.scan_default_sr(self._session) -- cgit From 68d894be2ec3b4eaa14dc5c90143f45f7db1e4b8 Mon Sep 17 00:00:00 2001 From: Cory Wright Date: Fri, 4 Mar 2011 17:48:28 +0000 Subject: * Tests to verify correct vm-params for Windows and Linux instances --- nova/virt/xenapi/vm_utils.py | 14 ++++++++------ nova/virt/xenapi/vmops.py | 8 +++----- 2 files changed, 11 insertions(+), 11 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 9c0bb5579..a26e391df 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -80,7 +80,8 @@ class VMHelper(HelperBase): """ @classmethod - def create_vm(cls, session, instance, kernel, ramdisk, use_pv_kernel=False): + def create_vm(cls, session, instance, kernel, ramdisk, + use_pv_kernel=False): """Create a VM record. Returns a Deferred that gives the new VM reference. the use_pv_kernel flag indicates whether the guest is HVM or PV @@ -319,7 +320,7 @@ class VMHelper(HelperBase): 'glance_host': FLAGS.glance_host, 'glance_port': FLAGS.glance_port, 'sr_path': get_sr_path(session), - 'os_type': instance.get('os_type', 'linux')} + 'os_type': instance.os_type} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'upload_vhd', kwargs) @@ -524,7 +525,7 @@ class VMHelper(HelperBase): Determine whether the VM will use a paravirtualized kernel or if it will use hardware virtualization. - 1. Objectstore (any image type): + 1. Objectstore (any image type): We use plugin to figure out whether the VDI uses PV 2. Glance (VHD): then we use `os_type`, raise if not set @@ -540,7 +541,8 @@ class VMHelper(HelperBase): session, vdi_ref, disk_image_type, os_type) else: # 1. Objecstore - return cls._determine_is_pv_objectstore(session, instance_id, vdi_ref) + return cls._determine_is_pv_objectstore(session, instance_id, + vdi_ref) @classmethod def _determine_is_pv_objectstore(cls, session, instance_id, vdi_ref): @@ -564,7 +566,7 @@ class VMHelper(HelperBase): """ For a Glance image, determine if we need paravirtualization. - The relevant scenarios are: + The relevant scenarios are: 2. Glance (VHD): then we use `os_type`, raise if not set 3. Glance (DISK_RAW): use Pygrub to figure out if pv kernel is @@ -582,7 +584,7 @@ class VMHelper(HelperBase): is_pv = True elif disk_image_type == ImageType.DISK_RAW: # 3. RAW - is_pv = with_vdi_attached_here(session, vdi_ref, True, _is_vdi_pv) + is_pv = with_vdi_attached_here(session, vdi_ref, True, _is_vdi_pv) elif disk_image_type == ImageType.DISK: # 4. Disk is_pv = True diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 1edf39c5b..eedb07a50 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -87,8 +87,6 @@ class VMOps(object): vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - os_type = instance.get('os_type', 'linux') - kernel = None if instance.kernel_id: kernel = VMHelper.fetch_image(self._session, instance.id, @@ -99,8 +97,8 @@ class VMOps(object): ramdisk = VMHelper.fetch_image(self._session, instance.id, instance.ramdisk_id, user, project, ImageType.KERNEL_RAMDISK) - use_pv_kernel = VMHelper.determine_is_pv( - self._session, instance.id, vdi_ref, disk_image_type, os_type) + use_pv_kernel = VMHelper.determine_is_pv(self._session, instance.id, + vdi_ref, disk_image_type, instance.os_type) vm_ref = VMHelper.create_vm(self._session, instance, kernel, ramdisk, use_pv_kernel) @@ -242,7 +240,7 @@ class VMOps(object): finally: self._destroy(instance, template_vm_ref, shutdown=False, destroy_kernel_ramdisk=False) - + logging.debug(_("Finished snapshot and upload for VM %s"), instance) def reboot(self, instance): -- cgit From e63cd9d5dc856f81477cf6c0e6c77ed7d1f4d70c Mon Sep 17 00:00:00 2001 From: Cory Wright Date: Fri, 4 Mar 2011 22:17:53 +0000 Subject: * os_type is no longer `not null` --- nova/virt/xenapi/vm_utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 7bff81b66..150824400 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -117,7 +117,7 @@ class VMHelper(HelperBase): 'memory_target': mem, 'name_description': '', 'name_label': instance.name, -# 'other_config': {'allowvssprovider': False}, + 'other_config': {'allowvssprovider': False}, 'other_config': {}, 'PCI_bus': '', 'platform': {'acpi': 'true', 'apic': 'true', 'pae': 'true', @@ -313,14 +313,14 @@ class VMHelper(HelperBase): logging.debug(_("Asking xapi to upload %(vdi_uuids)s as" " ID %(image_id)s") % locals()) - # TODO(dubs): os_type is currently defaulting to linux, we actually - # want to make this a NOT NULL column and require it to be specified. + os_type = instance.os_type and instance.os_type or 'linux' + params = {'vdi_uuids': vdi_uuids, 'image_id': image_id, 'glance_host': FLAGS.glance_host, 'glance_port': FLAGS.glance_port, 'sr_path': get_sr_path(session), - 'os_type': instance.os_type} + 'os_type': os_type} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'upload_vhd', kwargs) -- cgit From 7af17cbef6f3e1c5b052133e40e0edbd8ca9ffb3 Mon Sep 17 00:00:00 2001 From: Mark Washenberger Date: Sun, 6 Mar 2011 10:41:24 -0500 Subject: select cleanups --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 89d58a664..cf4bedaa9 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -316,7 +316,7 @@ class VMOps(object): def inject_file(self, instance, path, contents): """Write a file to the VM instance. The path to which it is to be - written and the contents of the file need to be supplied; both should + written and the contents of the file need to be supplied; both will be base64-encoded to prevent errors with non-ASCII characters being transmitted. If the agent does not support file injection, or the user has disabled it, a NotImplementedError will be raised. -- cgit From a5bee00af4d6ec3eed6ed0abd866948f4510f041 Mon Sep 17 00:00:00 2001 From: Vishvananda Ishaya Date: Mon, 7 Mar 2011 01:25:01 +0000 Subject: make compute get the new images properly, fix a bunch of tests, and provide conversion commands --- nova/virt/images.py | 25 +++++++++++++++---------- nova/virt/libvirt_conn.py | 8 +++++--- 2 files changed, 20 insertions(+), 13 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/images.py b/nova/virt/images.py index 7a6fef330..06b3a8ecd 100644 --- a/nova/virt/images.py +++ b/nova/virt/images.py @@ -28,29 +28,32 @@ import time import urllib2 import urlparse +from nova import context from nova import flags from nova import log as logging from nova import utils from nova.auth import manager from nova.auth import signer -from nova.objectstore import image FLAGS = flags.FLAGS -flags.DEFINE_bool('use_s3', True, - 'whether to get images from s3 or use local copy') - LOG = logging.getLogger('nova.virt.images') -def fetch(image, path, user, project): - if FLAGS.use_s3: - f = _fetch_s3_image - else: - f = _fetch_local_image - return f(image, path, user, project) +def fetch(image_id, path, _user, _project): + # TODO(vish): Improve context handling and add owner and auth data + # when it is added to glance. Right now there is no + # auth checking in glance, so we assume that access was + # checked before we got here. + image_service = utils.import_object(FLAGS.image_service) + with open(path, "wb") as image_file: + elevated = context.get_admin_context() + metadata = image_service.get(elevated, image_id, image_file) + return metadata +# NOTE(vish): The methods below should be unnecessary, but I'm leaving +# them in case the glance client does not work on windows. def _fetch_image_no_curl(url, path, headers): request = urllib2.Request(url) for (k, v) in headers.iteritems(): @@ -110,6 +113,8 @@ def _image_path(path): return os.path.join(FLAGS.images_path, path) +# TODO(vish): xenapi should use the glance client code directly instead +# of retrieving the image using this method. def image_url(image): if FLAGS.image_service == "nova.image.glance.GlanceImageService": return "http://%s:%s/images/%s" % (FLAGS.glance_host, diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9f7315c17..02a8208d5 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -579,21 +579,23 @@ class LibvirtConnection(object): 'ramdisk_id': inst['ramdisk_id']} if disk_images['kernel_id']: + fname = '%08x' % int(disk_images['kernel_id']) self._cache_image(fn=self._fetch_image, target=basepath('kernel'), - fname=disk_images['kernel_id'], + fname=fname, image_id=disk_images['kernel_id'], user=user, project=project) if disk_images['ramdisk_id']: + fname = '%08x' % int(disk_images['ramdisk_id']) self._cache_image(fn=self._fetch_image, target=basepath('ramdisk'), - fname=disk_images['ramdisk_id'], + fname=fname, image_id=disk_images['ramdisk_id'], user=user, project=project) - root_fname = disk_images['image_id'] + root_fname = '%08x' % int(disk_images['image_id']) size = FLAGS.minimum_root_size if inst['instance_type'] == 'm1.tiny' or suffix == '.rescue': size = None -- cgit From d940d4529b0102b83b98a52754bd897657a3355e Mon Sep 17 00:00:00 2001 From: sateesh Date: Mon, 7 Mar 2011 18:38:04 +0530 Subject: Fixed some more pep8 errors --- nova/virt/vmwareapi/__init__.py | 1 - nova/virt/vmwareapi/vim_util.py | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/__init__.py b/nova/virt/vmwareapi/__init__.py index 27e212a30..6dbcc157a 100644 --- a/nova/virt/vmwareapi/__init__.py +++ b/nova/virt/vmwareapi/__init__.py @@ -17,4 +17,3 @@ """ :mod:`vmwareapi` -- Nova support for VMware ESX/ESXi Server through vSphere API """ - diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py index e9756a025..20117b04c 100644 --- a/nova/virt/vmwareapi/vim_util.py +++ b/nova/virt/vmwareapi/vim_util.py @@ -30,7 +30,7 @@ def build_selcetion_spec(client_factory, name): def build_traversal_spec(client_factory, name, type, path, skip, select_set): """ Builds the traversal spec object """ traversal_spec = client_factory.create('ns0:TraversalSpec') - traversal_spec.name= name + traversal_spec.name = name traversal_spec.type = type traversal_spec.path = path traversal_spec.skip = skip -- cgit From a775c4eee279e11268a6cc447aee24c452e4665a Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Mon, 7 Mar 2011 17:17:41 +0000 Subject: Merge prop changes and test fixes --- nova/virt/xenapi/vm_utils.py | 30 ++++++++++++------------------ nova/virt/xenapi/vmops.py | 4 ++-- 2 files changed, 14 insertions(+), 20 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index eff207a51..80b7540d4 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -307,10 +307,16 @@ class VMHelper(HelperBase): return session.call_xenapi('SR.get_by_name_label', sr_label)[0] @classmethod - def get_sr_path(cls, session, sr_label='slices'): - """Finds the SR and then coerces it into a path on the dom0 file - system""" - return FLAGS.xenapi_sr_base_path + cls.get_sr(session, sr_label) + def get_sr_path(cls, session): + """Return the path to our storage repository + + This is used when we're dealing with VHDs directly, either by taking + snapshots or by restoring an image in the DISK_VHD format. + """ + sr_ref = safe_find_sr(session) + sr_rec = session.get_xenapi().SR.get_record(sr_ref) + sr_uuid = sr_rec["uuid"] + return os.path.join(FLAGS.xenapi_sr_base_path, sr_uuid) @classmethod def upload_image(cls, session, instance_id, vdi_uuids, image_id): @@ -326,7 +332,7 @@ class VMHelper(HelperBase): 'image_id': image_id, 'glance_host': FLAGS.glance_host, 'glance_port': FLAGS.glance_port, - 'sr_path': get_sr_path(session)} + 'sr_path': cls.get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'upload_vhd', kwargs) @@ -369,7 +375,7 @@ class VMHelper(HelperBase): 'glance_host': FLAGS.glance_host, 'glance_port': FLAGS.glance_port, 'uuid_stack': uuid_stack, - 'sr_path': get_sr_path(session)} + 'sr_path': cls.get_sr_path(session)} kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'download_vhd', kwargs) @@ -775,18 +781,6 @@ def find_sr(session): return None -def get_sr_path(session): - """Return the path to our storage repository - - This is used when we're dealing with VHDs directly, either by taking - snapshots or by restoring an image in the DISK_VHD format. - """ - sr_ref = safe_find_sr(session) - sr_rec = session.get_xenapi().SR.get_record(sr_ref) - sr_uuid = sr_rec["uuid"] - return os.path.join(FLAGS.xenapi_sr_base_path, sr_uuid) - - def remap_vbd_dev(dev): """Return the appropriate location for a plugged-in VBD device diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 01bfa2dc5..b862c9de9 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -262,7 +262,7 @@ class VMOps(object): self._session, instance.id, template_vdi_uuids, image_id) finally: if template_vm_ref: - self.virt._destroy(self.instance, template_vm_ref, + self._destroy(instance, template_vm_ref, shutdown=False, destroy_kernel_ramdisk=False) logging.debug(_("Finished snapshot and upload for VM %s"), instance) @@ -330,7 +330,7 @@ class VMOps(object): finally: if template_vm_ref: - self.virt._destroy(self.instance, template_vm_ref, + self._destroy(instance, template_vm_ref, shutdown=False, destroy_kernel_ramdisk=False) # TODO(mdietz): we could also consider renaming these to something -- cgit From 4e9c570fbf8b3987d556da085b61f159f32c16f1 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Mon, 7 Mar 2011 21:59:05 +0100 Subject: Use IptablesManager.semapahore from securitygroups driver to ensure we don't apply half a rule set. --- nova/virt/libvirt_conn.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index b900cb8eb..825bcb0d7 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1372,8 +1372,12 @@ class IptablesFirewallDriver(FirewallDriver): def refresh_security_group_rules(self, security_group): for instance in self.instances.values(): - self.remove_filters_for_instance(instance) - self.add_filters_for_instance(instance) + # We use the semaphore to make sure noone applies the rule set + # after we've yanked the existing rules but before we've put in + # the new ones. + with self.iptables.semaphore: + self.remove_filters_for_instance(instance) + self.add_filters_for_instance(instance) self.iptables.apply() def _security_group_chain_name(self, security_group_id): -- cgit From f79220a1f6a12621463b410d26e31e29a9e6ea3e Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 7 Mar 2011 15:41:37 -0600 Subject: cleaned up virt.xenapi.vmops._get_vm_opaque_ref. more reliable approach to checking if param is an opaque ref. code is cleaner --- nova/virt/xenapi/vmops.py | 44 +++++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 21 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b862c9de9..b1671fde4 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -188,30 +188,32 @@ class VMOps(object): """Refactored out the common code of many methods that receive either a vm name or a vm instance, and want a vm instance in return. """ - vm = None - try: - if instance_or_vm.startswith("OpaqueRef:"): - # Got passed an opaque ref; return it + # if instance_or_vm is a string it must be opaque ref or instance name + if isinstance(instance_or_vm, str): + vm_rec = self._session.get_xenapi().VM.get_record(instance_or_vm) + if vm_rec != None: + # an opaque ref was passed in, return it return instance_or_vm else: - # Must be the instance name + # it must be an instance name instance_name = instance_or_vm - except (AttributeError, KeyError): - # Note the the KeyError will only happen with fakes.py - # Not a string; must be an ID or a vm instance - if isinstance(instance_or_vm, (int, long)): - ctx = context.get_admin_context() - try: - instance_obj = db.instance_get(ctx, instance_or_vm) - instance_name = instance_obj.name - except exception.NotFound: - # The unit tests screw this up, as they use an integer for - # the vm name. I'd fix that up, but that's a matter for - # another bug report. So for now, just try with the passed - # value - instance_name = instance_or_vm - else: - instance_name = instance_or_vm.name + + # if instance_or_vm is an int/long it must be instance id + elif isinstance(instance_or_vm, (int, long)): + ctx = context.get_admin_context() + try: + instance_obj = db.instance_get(ctx, instance_or_vm) + instance_name = instance_obj.name + except exception.NotFound: + # The unit tests screw this up, as they use an integer for + # the vm name. I'd fix that up, but that's a matter for + # another bug report. So for now, just try with the passed + # value + instance_name = instance_or_vm + + # otherwise instance_or_vm is an instance object + else: + instance_name = instance_or_vm.name vm = VMHelper.lookup(self._session, instance_name) if vm is None: raise exception.NotFound( -- cgit From 59f73e3180731cec644b590d448e0da74711ae03 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 7 Mar 2011 16:11:10 -0600 Subject: virt.xenapi.vmops._get_vm_opaque_ref exception caught properly --- nova/virt/xenapi/vmops.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b1671fde4..ae4609418 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -190,13 +190,16 @@ class VMOps(object): """ # if instance_or_vm is a string it must be opaque ref or instance name if isinstance(instance_or_vm, str): - vm_rec = self._session.get_xenapi().VM.get_record(instance_or_vm) - if vm_rec != None: - # an opaque ref was passed in, return it - return instance_or_vm - else: - # it must be an instance name - instance_name = instance_or_vm + ref = None + try: + ref = self._session.get_xenapi().VM.get_record(instance_or_vm) + if ref != None: + # an opaque ref was passed in, return it + return instance_or_vm + except: + pass + # wasn't an opaque ref, must be an instance name + instance_name = instance_or_vm # if instance_or_vm is an int/long it must be instance id elif isinstance(instance_or_vm, (int, long)): -- cgit From 3fc6b8cbbd1be5baffc300112a0e39a807209c36 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 7 Mar 2011 16:34:59 -0600 Subject: virt.xenapi.vmops._get_vm_opaque_ref checks for basestring instance instead of str --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ae4609418..30fa5bdd7 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -189,7 +189,7 @@ class VMOps(object): a vm name or a vm instance, and want a vm instance in return. """ # if instance_or_vm is a string it must be opaque ref or instance name - if isinstance(instance_or_vm, str): + if isinstance(instance_or_vm, basestring): ref = None try: ref = self._session.get_xenapi().VM.get_record(instance_or_vm) -- cgit From 88c5555e867c730065c18541a35b161eb861b502 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Mon, 7 Mar 2011 16:40:19 -0600 Subject: First part of the bug fix --- nova/virt/xenapi/vmops.py | 8 +++++++- nova/virt/xenapi_conn.py | 9 +++++++-- 2 files changed, 14 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b862c9de9..37f513599 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -72,7 +72,13 @@ class VMOps(object): LOG.debug(_("Starting instance %s"), instance.name) self._session.call_xenapi('VM.start', vm_ref, False, False) - def spawn(self, instance, disk): + def spawn(self, instance): + self._spawn(instance, disk=None) + + def spawn_with_disk(self, instance, disk): + self._spawn(instance, disk=disk) + + def _spawn(self, instance, disk): """Create VM instance""" instance_name = instance.name vm = VMHelper.lookup(self._session, instance_name) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 62e17e851..7e8f825e9 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -154,9 +154,14 @@ class XenAPIConnection(object): """List VM instances""" return self._vmops.list_instances() - def spawn(self, instance, disk=None): + def spawn(self, instance): """Create VM instance""" - self._vmops.spawn(instance, disk) + self._vmops.spawn(instance) + + def finish_resize(self, instance, disk_info) + """Completes a resize, turning on the migrated instance""" + new_disk_info = self.attach_disk(instance, disk_info) + self._vmops.spawn_with_disk(instance, new_disk_info) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From 5c7ee13b058fb954fd9bbc4a3550716b8faa0b97 Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Mon, 7 Mar 2011 22:50:35 +0000 Subject: And unit tests --- nova/virt/xenapi_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 7e8f825e9..3991496b2 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -158,7 +158,7 @@ class XenAPIConnection(object): """Create VM instance""" self._vmops.spawn(instance) - def finish_resize(self, instance, disk_info) + def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" new_disk_info = self.attach_disk(instance, disk_info) self._vmops.spawn_with_disk(instance, new_disk_info) -- cgit From 2f0845b7b80081d18ee268b94fe38326f3c5401e Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Mon, 7 Mar 2011 23:07:05 +0000 Subject: A few more changes --- nova/virt/xenapi/vmops.py | 10 +++++----- nova/virt/xenapi_conn.py | 9 +++------ 2 files changed, 8 insertions(+), 11 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 37f513599..e658de7f3 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -75,8 +75,8 @@ class VMOps(object): def spawn(self, instance): self._spawn(instance, disk=None) - def spawn_with_disk(self, instance, disk): - self._spawn(instance, disk=disk) + def spawn_with_disk(self, instance, vdi_uuid): + self._spawn(instance, disk=vdi_uuid) def _spawn(self, instance, disk): """Create VM instance""" @@ -343,14 +343,14 @@ class VMOps(object): # sensible so we don't need to blindly pass around dictionaries return {'base_copy': base_copy_uuid, 'cow': cow_uuid} - def attach_disk(self, instance, disk_info): + def attach_disk(self, instance, base_copy_uuid, cow_uuid): """Links the base copy VHD to the COW via the XAPI plugin""" vm_ref = VMHelper.lookup(self._session, instance.name) new_base_copy_uuid = str(uuid.uuid4()) new_cow_uuid = str(uuid.uuid4()) params = {'instance_id': instance.id, - 'old_base_copy_uuid': disk_info['base_copy'], - 'old_cow_uuid': disk_info['cow'], + 'old_base_copy_uuid': base_copy_uuid, + 'old_cow_uuid': cow_uuid, 'new_base_copy_uuid': new_base_copy_uuid, 'new_cow_uuid': new_cow_uuid, 'sr_path': VMHelper.get_sr_path(self._session), } diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 3991496b2..9965accad 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -160,8 +160,9 @@ class XenAPIConnection(object): def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" - new_disk_info = self.attach_disk(instance, disk_info) - self._vmops.spawn_with_disk(instance, new_disk_info) + cow_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], + disk_info['cow']) + self._vmops.spawn_with_disk(instance, cow_uuid) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ @@ -202,10 +203,6 @@ class XenAPIConnection(object): off the instance copies over the COW disk""" return self._vmops.migrate_disk_and_power_off(instance, dest) - def attach_disk(self, instance, disk_info): - """Moves the copied VDIs into the SR""" - return self._vmops.attach_disk(instance, disk_info) - def suspend(self, instance, callback): """suspend the specified instance""" self._vmops.suspend(instance, callback) -- cgit From e39995def6a2a11cdd430b0e6f603b493be5542b Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Mon, 7 Mar 2011 23:51:20 +0000 Subject: Some more refactoring and a tighter unit test --- nova/virt/xenapi/vmops.py | 30 ++++++++++++++---------------- nova/virt/xenapi_conn.py | 4 ++-- 2 files changed, 16 insertions(+), 18 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index e658de7f3..7fe1f6ff0 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -72,13 +72,19 @@ class VMOps(object): LOG.debug(_("Starting instance %s"), instance.name) self._session.call_xenapi('VM.start', vm_ref, False, False) - def spawn(self, instance): - self._spawn(instance, disk=None) - - def spawn_with_disk(self, instance, vdi_uuid): - self._spawn(instance, disk=vdi_uuid) + def create_disk(self, instance): + user = AuthManager().get_user(instance.user_id) + project = AuthManager().get_project(instance.project_id) + disk_image_type = VMHelper.determine_disk_image_type(instance) + vdi_uuid = VMHelper.fetch_image(self._session, instance.id, + instance.image_id, user, project, disk_image_type) + return vdi_uuid - def _spawn(self, instance, disk): + def spawn(self, instance): + vdi_uuid = self.create_disk(instance) + self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) + + def _spawn_with_disk(self, instance, vdi_uuid): """Create VM instance""" instance_name = instance.name vm = VMHelper.lookup(self._session, instance_name) @@ -101,17 +107,9 @@ class VMOps(object): vdi_ref = kernel = ramdisk = pv_kernel = None # Are we building from a pre-existing disk? - if not disk: - #if kernel is not present we must download a raw disk - - disk_image_type = VMHelper.determine_disk_image_type(instance) - vdi_uuid = VMHelper.fetch_image(self._session, instance.id, - instance.image_id, user, project, disk_image_type) - vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - - else: - vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', disk) + vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) + disk_image_type = VMHelper.determine_disk_image_type(instance) if disk_image_type == ImageType.DISK_RAW: # Have a look at the VDI and see if it has a PV kernel pv_kernel = VMHelper.lookup_image(self._session, instance.id, diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 9965accad..b63a5f8c3 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -160,9 +160,9 @@ class XenAPIConnection(object): def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" - cow_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], + vdi_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], disk_info['cow']) - self._vmops.spawn_with_disk(instance, cow_uuid) + self._vmops._spawn_with_disk(instance, vdi_uuid) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From 5ec9cbcdee3de3868a47ca5ec351a9a2594ceea2 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 7 Mar 2011 18:05:27 -0600 Subject: virt.xenapi.vmops._get_vm_opaque_ref assumes VM.get_record raises --- nova/virt/xenapi/vmops.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 30fa5bdd7..c0fbf96fc 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -192,14 +192,12 @@ class VMOps(object): if isinstance(instance_or_vm, basestring): ref = None try: + # check for opaque ref ref = self._session.get_xenapi().VM.get_record(instance_or_vm) - if ref != None: - # an opaque ref was passed in, return it - return instance_or_vm - except: - pass - # wasn't an opaque ref, must be an instance name - instance_name = instance_or_vm + return instance_or_vm + except self.XenAPI.Failure: + # wasn't an opaque ref, must be an instance name + instance_name = instance_or_vm # if instance_or_vm is an int/long it must be instance id elif isinstance(instance_or_vm, (int, long)): -- cgit From 4e8b6a14324ef2d1f550233cbcfc94c6363533d8 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 7 Mar 2011 18:46:44 -0600 Subject: virt.xenapi.vmops._get_vm_opaque_ref changed vm to vm_ref and ref to obj --- nova/virt/xenapi/vmops.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index c0fbf96fc..0adabe7f5 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -190,10 +190,10 @@ class VMOps(object): """ # if instance_or_vm is a string it must be opaque ref or instance name if isinstance(instance_or_vm, basestring): - ref = None + obj = None try: # check for opaque ref - ref = self._session.get_xenapi().VM.get_record(instance_or_vm) + obj = self._session.get_xenapi().VM.get_record(instance_or_vm) return instance_or_vm except self.XenAPI.Failure: # wasn't an opaque ref, must be an instance name @@ -215,11 +215,11 @@ class VMOps(object): # otherwise instance_or_vm is an instance object else: instance_name = instance_or_vm.name - vm = VMHelper.lookup(self._session, instance_name) - if vm is None: + vm_ref = VMHelper.lookup(self._session, instance_name) + if vm_ref is None: raise exception.NotFound( _('Instance not present %s') % instance_name) - return vm + return vm_ref def _acquire_bootlock(self, vm): """Prevent an instance from booting""" -- cgit From cac5881eaa35f94e004c18dd34ca78014f067976 Mon Sep 17 00:00:00 2001 From: Eric Windisch Date: Tue, 8 Mar 2011 01:01:41 -0500 Subject: execvp --- nova/virt/disk.py | 44 +++++++++++++++++++++++--------------------- nova/virt/images.py | 5 ++--- nova/virt/libvirt_conn.py | 36 +++++++++++++++++++++--------------- nova/virt/xenapi/vm_utils.py | 11 ++++++----- 4 files changed, 52 insertions(+), 44 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 2bded07a4..203517275 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -49,10 +49,10 @@ def extend(image, size): file_size = os.path.getsize(image) if file_size >= size: return - utils.execute('truncate -s %s %s' % (size, image)) + utils.execute('truncate', '-s', size, image) # NOTE(vish): attempts to resize filesystem - utils.execute('e2fsck -fp %s' % image, check_exit_code=False) - utils.execute('resize2fs %s' % image, check_exit_code=False) + utils.execute('e2fsck', '-fp', mage, check_exit_code=False) + utils.execute('resize2fs', image, check_exit_code=False) def inject_data(image, key=None, net=None, partition=None, nbd=False): @@ -68,7 +68,7 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): try: if not partition is None: # create partition - out, err = utils.execute('sudo kpartx -a %s' % device) + out, err = utils.execute('sudo', 'kpartx', '-a', device) if err: raise exception.Error(_('Failed to load partition: %s') % err) mapped_device = '/dev/mapper/%sp%s' % (device.split('/')[-1], @@ -84,13 +84,14 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): mapped_device) # Configure ext2fs so that it doesn't auto-check every N boots - out, err = utils.execute('sudo tune2fs -c 0 -i 0 %s' % mapped_device) + out, err = utils.execute('sudo', 'tune2fs', + '-c', 0, '-i', 0, mapped_device) tmpdir = tempfile.mkdtemp() try: # mount loopback to dir out, err = utils.execute( - 'sudo mount %s %s' % (mapped_device, tmpdir)) + 'sudo', 'mount', mapped_device, tmpdir) if err: raise exception.Error(_('Failed to mount filesystem: %s') % err) @@ -103,13 +104,13 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): _inject_net_into_fs(net, tmpdir) finally: # unmount device - utils.execute('sudo umount %s' % mapped_device) + utils.execute('sudo', 'umount', mapped_device) finally: # remove temporary directory - utils.execute('rmdir %s' % tmpdir) + utils.execute('rmdir', tmpdir) if not partition is None: # remove partitions - utils.execute('sudo kpartx -d %s' % device) + utils.execute('sudo', 'kpartx', '-d', device) finally: _unlink_device(device, nbd) @@ -118,7 +119,7 @@ def _link_device(image, nbd): """Link image to device using loopback or nbd""" if nbd: device = _allocate_device() - utils.execute('sudo qemu-nbd -c %s %s' % (device, image)) + utils.execute('sudo', 'qemu-nbd', '-c', device, image) # NOTE(vish): this forks into another process, so give it a chance # to set up before continuuing for i in xrange(FLAGS.timeout_nbd): @@ -127,7 +128,7 @@ def _link_device(image, nbd): time.sleep(1) raise exception.Error(_('nbd device %s did not show up') % device) else: - out, err = utils.execute('sudo losetup --find --show %s' % image) + out, err = utils.execute('sudo', 'losetup', '--find', '--show', image) if err: raise exception.Error(_('Could not attach image to loopback: %s') % err) @@ -137,10 +138,10 @@ def _link_device(image, nbd): def _unlink_device(device, nbd): """Unlink image from device using loopback or nbd""" if nbd: - utils.execute('sudo qemu-nbd -d %s' % device) + utils.execute('sudo', 'qemu-nbd', '-d', device) _free_device(device) else: - utils.execute('sudo losetup --detach %s' % device) + utils.execute('sudo', 'losetup', '--detach', device) _DEVICES = ['/dev/nbd%s' % i for i in xrange(FLAGS.max_nbd_devices)] @@ -170,11 +171,12 @@ def _inject_key_into_fs(key, fs): fs is the path to the base of the filesystem into which to inject the key. """ sshdir = os.path.join(fs, 'root', '.ssh') - utils.execute('sudo mkdir -p %s' % sshdir) # existing dir doesn't matter - utils.execute('sudo chown root %s' % sshdir) - utils.execute('sudo chmod 700 %s' % sshdir) + utils.execute('sudo', 'mkdir', '-p', sshdir) # existing dir doesn't matter + utils.execute('sudo', 'chown', 'root', sshdir) + utils.execute('sudo', 'chmod', '700', sshdir) keyfile = os.path.join(sshdir, 'authorized_keys') - utils.execute('sudo tee -a %s' % keyfile, '\n' + key.strip() + '\n') + # TODO:EWINDISCH: not sure about the following /w execv patch + utils.execute('sudo', 'tee', '-a', keyfile, '\n' + key.strip() + '\n') def _inject_net_into_fs(net, fs): @@ -183,8 +185,8 @@ def _inject_net_into_fs(net, fs): net is the contents of /etc/network/interfaces. """ netdir = os.path.join(os.path.join(fs, 'etc'), 'network') - utils.execute('sudo mkdir -p %s' % netdir) # existing dir doesn't matter - utils.execute('sudo chown root:root %s' % netdir) - utils.execute('sudo chmod 755 %s' % netdir) + utils.execute('sudo', 'mkdir', '-p', netdir) # existing dir doesn't matter + utils.execute('sudo', 'chown', 'root:root', netdir) + utils.execute('sudo', 'chmod', 755, netdir) netfile = os.path.join(netdir, 'interfaces') - utils.execute('sudo tee %s' % netfile, net) + utils.execute('sudo', 'tee', netfile, net) diff --git a/nova/virt/images.py b/nova/virt/images.py index 7a6fef330..4b11d1667 100644 --- a/nova/virt/images.py +++ b/nova/virt/images.py @@ -94,8 +94,7 @@ def _fetch_s3_image(image, path, user, project): cmd += ['-H', '\'%s: %s\'' % (k, v)] cmd += ['-o', path] - cmd_out = ' '.join(cmd) - return utils.execute(cmd_out) + return utils.execute(*cmd) def _fetch_local_image(image, path, user, project): @@ -103,7 +102,7 @@ def _fetch_local_image(image, path, user, project): if sys.platform.startswith('win'): return shutil.copy(source, path) else: - return utils.execute('cp %s %s' % (source, path)) + return utils.execute('cp', source, path) def _image_path(path): diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4e0fd106f..464ec475c 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -438,8 +438,10 @@ class LibvirtConnection(object): if virsh_output.startswith('/dev/'): LOG.info(_("cool, it's a device")) - out, err = utils.execute("sudo dd if=%s iflag=nonblock" % - virsh_output, check_exit_code=False) + out, err = utils.execute('sudo', 'dd', + "if=%s" % virsh_output, + 'iflag=nonblock', + check_exit_code=False) return out else: return '' @@ -461,11 +463,11 @@ class LibvirtConnection(object): console_log = os.path.join(FLAGS.instances_path, instance['name'], 'console.log') - utils.execute('sudo chown %d %s' % (os.getuid(), console_log)) + utils.execute('sudo', 'chown', s.getuid(), console_log) if FLAGS.libvirt_type == 'xen': # Xen is special - virsh_output = utils.execute("virsh ttyconsole %s" % + virsh_output = utils.execute('virsh', 'ttyconsole', instance['name']) data = self._flush_xen_console(virsh_output) fpath = self._append_to_file(data, console_log) @@ -482,7 +484,10 @@ class LibvirtConnection(object): port = random.randint(int(start_port), int(end_port)) # netcat will exit with 0 only if the port is in use, # so a nonzero return value implies it is unused - cmd = 'netcat 0.0.0.0 %s -w 1 Date: Tue, 8 Mar 2011 01:08:13 -0500 Subject: Fix todo comment --- nova/virt/libvirt_conn.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e1cd75306..a5256bbc2 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -486,8 +486,9 @@ class LibvirtConnection(object): # netcat will exit with 0 only if the port is in use, # so a nonzero return value implies it is unused - # TODO:ewindisch: subprocess lets us do this... - # but utils.execute abstracts it away from us + # TODO(ewindisch): broken /w execvp patch. + # subprocess lets us do this, but utils.execute + # abstracts it away from us cmd = 'netcat', '0.0.0.0', port, '-w', '1', ' Date: Tue, 8 Mar 2011 14:35:53 +0000 Subject: * pep8 cleanups in migrations * a few bugfixes --- nova/virt/xenapi/vm_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 150824400..604e8a4e0 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -324,7 +324,7 @@ class VMHelper(HelperBase): kwargs = {'params': pickle.dumps(params)} task = session.async_call_plugin('glance', 'upload_vhd', kwargs) - session.wait_for_task(task, instance_id) + session.wait_for_task(task, instance.id) @classmethod def fetch_image(cls, session, instance_id, image, user, project, -- cgit From 1caceddf431a1ad1ef22235c2206bccf39fde5c5 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 8 Mar 2011 14:24:01 -0600 Subject: Nits --- nova/virt/xenapi/vmops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 7fe1f6ff0..86dbf251b 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -90,7 +90,7 @@ class VMOps(object): vm = VMHelper.lookup(self._session, instance_name) if vm is not None: raise exception.Duplicate(_('Attempted to create' - ' non-unique name %s') % instance_name) + ' non-unique name %s') % instance_name) #ensure enough free memory is available if not VMHelper.ensure_free_mem(self._session, instance): @@ -104,7 +104,7 @@ class VMOps(object): user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) - vdi_ref = kernel = ramdisk = pv_kernel = None + kernel = ramdisk = pv_kernel = None # Are we building from a pre-existing disk? vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) -- cgit From dd2f0019297d01fe5d6b3dae4efc72946191be75 Mon Sep 17 00:00:00 2001 From: Rick Harris Date: Tue, 8 Mar 2011 22:14:25 +0000 Subject: Use disk_format and container_format instead of image type --- nova/virt/xenapi/vm_utils.py | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 80b7540d4..ce081a2d6 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -467,19 +467,21 @@ class VMHelper(HelperBase): "%(image_id)s, instance %(instance_id)s") % locals()) def determine_from_glance(): - glance_type2nova_type = {'machine': ImageType.DISK, - 'raw': ImageType.DISK_RAW, - 'vhd': ImageType.DISK_VHD, - 'kernel': ImageType.KERNEL_RAMDISK, - 'ramdisk': ImageType.KERNEL_RAMDISK} + glance_disk_format2nova_type = { + 'ami': ImageType.DISK, + 'aki': ImageType.KERNEL_RAMDISK, + 'ari': ImageType.KERNEL_RAMDISK, + 'raw': ImageType.DISK_RAW, + 'vhd': ImageType.DISK_VHD} client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) meta = client.get_image_meta(instance.image_id) - type_ = meta['type'] + disk_format = meta['disk_format'] try: - return glance_type2nova_type[type_] + return glance_disk_format2nova_type[disk_format] except KeyError: raise exception.NotFound( - _("Unrecognized image type '%(type_)s'") % locals()) + _("Unrecognized disk_format '%(disk_format)s'") + % locals()) def determine_from_instance(): if instance.kernel_id: -- cgit From 698398fdc2a05a0930591d3f3d386ad24a322359 Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Tue, 8 Mar 2011 23:24:19 +0000 Subject: Pep8 fixes --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 43c23806e..562ecd4d5 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -83,7 +83,7 @@ class VMOps(object): def spawn(self, instance): vdi_uuid = self.create_disk(instance) self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) - + def _spawn_with_disk(self, instance, vdi_uuid): """Create VM instance""" instance_name = instance.name -- cgit From e7626da8ade4a3d29d441fed1c21c50cbc9928de Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Tue, 8 Mar 2011 23:33:17 +0000 Subject: using get_uuid in place of get_record in _get_vm_opaqueref changed SessionBase._getter in fake xenapi in order to return HANDLE_INVALID failure when reference is not in DB (was NotImplementedException) --- nova/virt/xenapi/fake.py | 11 ++++++----- nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 7 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 09e381e2c..eecfa20b1 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -400,7 +400,6 @@ class SessionBase(object): def _getter(self, name, params): self._check_session(params) (cls, func) = name.split('.') - if func == 'get_all': self._check_arg_count(params, 1) return get_all(cls) @@ -423,10 +422,12 @@ class SessionBase(object): if len(params) == 2: field = func[len('get_'):] ref = params[1] - - if (ref in _db_content[cls] and - field in _db_content[cls][ref]): - return _db_content[cls][ref][field] + if (ref in _db_content[cls]): + if (field in _db_content[cls][ref]): + return _db_content[cls][ref][field] + else: + LOG.debug(_('Raising Failure')) + raise Failure(['HANDLE_INVALID', cls, ref]) LOG.debug(_('Raising NotImplemented')) raise NotImplementedError( diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ddd5b0e16..273a7ba38 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -198,7 +198,7 @@ class VMOps(object): obj = None try: # check for opaque ref - obj = self._session.get_xenapi().VM.get_record(instance_or_vm) + obj = self._session.get_xenapi().VM.get_uuid(instance_or_vm) return instance_or_vm except self.XenAPI.Failure: # wasn't an opaque ref, can be an instance name -- cgit From e4b176d41cca234082c28ba6d9188745f1d2b98a Mon Sep 17 00:00:00 2001 From: Cory Wright Date: Wed, 9 Mar 2011 00:49:56 +0000 Subject: a few fixes for the tests --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a6a9fbf95..aa4372c3d 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -261,7 +261,7 @@ class VMOps(object): template_vm_ref, template_vdi_uuids = self._get_snapshot(instance) # call plugin to ship snapshot off to glance VMHelper.upload_image( - self._session, instance.id, template_vdi_uuids, image_id) + self._session, instance, template_vdi_uuids, image_id) finally: if template_vm_ref: self._destroy(instance, template_vm_ref, -- cgit From a320b5df9f916adf8422ed312306c77570d392c2 Mon Sep 17 00:00:00 2001 From: Eric Windisch Date: Wed, 9 Mar 2011 00:30:05 -0500 Subject: execvp: almost passes tests --- nova/virt/libvirt_conn.py | 11 ++++++----- nova/virt/xenapi/vm_utils.py | 6 ++---- 2 files changed, 8 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index a5256bbc2..76f31f91a 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -540,8 +540,8 @@ class LibvirtConnection(object): if not os.path.exists(base): fn(target=base, *args, **kwargs) if cow: - utils.execute('qemu-img', 'create', '-f', 'qcow2', "'-o'', - "cluster_size=2M,backing_file=%s" % base, + utils.execute('qemu-img', 'create', '-f', 'qcow2', '-o', + 'cluster_size=2M,backing_file=%s' % base, target) else: utils.execute('cp', base, target) @@ -554,7 +554,7 @@ class LibvirtConnection(object): def _create_local(self, target, local_gb): """Create a blank image of specified size""" - utils.execute('truncate', target, '-s', "%dG" local_gb) + utils.execute('truncate', target, '-s', "%dG" % local_gb) # TODO(vish): should we format disk by default? def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None): @@ -565,7 +565,7 @@ class LibvirtConnection(object): fname + suffix) # ensure directories exist and are writable - utils.execute('mkdir', '-p', basepath(suffix='') + utils.execute('mkdir', '-p', basepath(suffix='')) LOG.info(_('instance %s: Creating image'), inst['name']) f = open(basepath('libvirt.xml'), 'w') @@ -1245,7 +1245,8 @@ class IptablesFirewallDriver(FirewallDriver): self.apply_ruleset() def apply_ruleset(self): - current_filter, _ = self.execute('sudo iptables-save -t filter') + current_filter, _ = self.execute('sudo', 'iptables-save', + '-t', 'filter') current_lines = current_filter.split('\n') new_filter = self.modify_rules(current_lines, 4) self.execute('sudo', 'iptables-restore', diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 8fdb658fb..6ba13f980 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -915,10 +915,8 @@ def _write_partition(virtual_size, dev): LOG.debug(_('Writing partition table %(primary_first)d %(primary_last)d' ' to %(dest)s...') % locals()) - def execute(*cmd, process_input=None, check_exit_code=True): - return utils.execute(*cmd, - process_input=process_input, - check_exit_code=check_exit_code) + def execute(*cmd, **kwargs): + return utils.execute(*cmd, **kwargs) execute('parted', '--script', dest, 'mklabel', 'msdos') execute('parted', '--script', dest, 'mkpart', 'primary', -- cgit From 77da93886be61230dea5a4a4c4de036a57e62550 Mon Sep 17 00:00:00 2001 From: Vishvananda Ishaya Date: Wed, 9 Mar 2011 06:56:42 +0000 Subject: tests and semaphore fix for image caching --- nova/virt/libvirt_conn.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9f7315c17..1a1f146d4 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -44,9 +44,8 @@ import uuid from xml.dom import minidom -from eventlet import greenthread -from eventlet import event from eventlet import tpool +from eventlet import semaphore import IPy @@ -512,6 +511,8 @@ class LibvirtConnection(object): subprocess.Popen(cmd, shell=True) return {'token': token, 'host': host, 'port': port} + _image_semaphores = {} + def _cache_image(self, fn, target, fname, cow=False, *args, **kwargs): """Wrapper for a method that creates an image that caches the image. @@ -531,8 +532,13 @@ class LibvirtConnection(object): if not os.path.exists(base_dir): os.mkdir(base_dir) base = os.path.join(base_dir, fname) - if not os.path.exists(base): - fn(target=base, *args, **kwargs) + + if fname not in self._image_semaphores: + self._image_semaphores[fname] = semaphore.Semaphore() + with self._image_semaphores[fname]: + if not os.path.exists(base): + fn(target=base, *args, **kwargs) + if cow: utils.execute('qemu-img create -f qcow2 -o ' 'cluster_size=2M,backing_file=%s %s' -- cgit From ddeab2da30bb2f74109854d982c6681e78e7a4ce Mon Sep 17 00:00:00 2001 From: Vishvananda Ishaya Date: Wed, 9 Mar 2011 07:35:58 +0000 Subject: make static method for testing without initializing libvirt --- nova/virt/libvirt_conn.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 1a1f146d4..ecef7950a 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -511,9 +511,10 @@ class LibvirtConnection(object): subprocess.Popen(cmd, shell=True) return {'token': token, 'host': host, 'port': port} - _image_semaphores = {} + _image_sems = {} - def _cache_image(self, fn, target, fname, cow=False, *args, **kwargs): + @staticmethod + def _cache_image(fn, target, fname, cow=False, *args, **kwargs): """Wrapper for a method that creates an image that caches the image. This wrapper will save the image into a common store and create a @@ -533,9 +534,9 @@ class LibvirtConnection(object): os.mkdir(base_dir) base = os.path.join(base_dir, fname) - if fname not in self._image_semaphores: - self._image_semaphores[fname] = semaphore.Semaphore() - with self._image_semaphores[fname]: + if fname not in LibvirtConnection._image_sems: + LibvirtConnection._image_sems[fname] = semaphore.Semaphore() + with LibvirtConnection._image_sems[fname]: if not os.path.exists(base): fn(target=base, *args, **kwargs) -- cgit From 23369a63f4b74fb64bf57554a3fd8b15e3e2b49c Mon Sep 17 00:00:00 2001 From: Eric Windisch Date: Wed, 9 Mar 2011 14:31:23 -0500 Subject: Fixes uses of process_input --- nova/virt/disk.py | 4 ++-- nova/virt/libvirt_conn.py | 11 ++++------- 2 files changed, 6 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 203517275..a54cda003 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -175,8 +175,8 @@ def _inject_key_into_fs(key, fs): utils.execute('sudo', 'chown', 'root', sshdir) utils.execute('sudo', 'chmod', '700', sshdir) keyfile = os.path.join(sshdir, 'authorized_keys') - # TODO:EWINDISCH: not sure about the following /w execv patch - utils.execute('sudo', 'tee', '-a', keyfile, '\n' + key.strip() + '\n') + utils.execute('sudo', 'tee', '-a', keyfile, + process_input='\n' + key.strip() + '\n') def _inject_net_into_fs(net, fs): diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 76f31f91a..6b555ecbb 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -485,13 +485,10 @@ class LibvirtConnection(object): port = random.randint(int(start_port), int(end_port)) # netcat will exit with 0 only if the port is in use, # so a nonzero return value implies it is unused - - # TODO(ewindisch): broken /w execvp patch. - # subprocess lets us do this, but utils.execute - # abstracts it away from us - cmd = 'netcat', '0.0.0.0', port, '-w', '1', ' Date: Wed, 9 Mar 2011 14:55:36 -0600 Subject: Added naming scheme comment --- nova/virt/xenapi_conn.py | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index b63a5f8c3..bfe290be3 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -49,6 +49,12 @@ reactor thread if the VM.get_by_name_label or VM.get_record calls block. address for the nova-volume host :target_port: iSCSI Target Port, 3260 Default :iqn_prefix: IQN Prefix, e.g. 'iqn.2010-10.org.openstack' + +**Variable Naming Scheme** + +- suffix "_ref" for opaque references +- suffix "_uuid" for UUIDs +- suffix "_rec" for record objects """ import sys -- cgit From 3e61bf9963d7e98e8152d2eacfc4461d8cda309c Mon Sep 17 00:00:00 2001 From: Vishvananda Ishaya Date: Wed, 9 Mar 2011 21:43:35 +0000 Subject: remove the semaphore when there is no one waiting on it --- nova/virt/libvirt_conn.py | 2 ++ 1 file changed, 2 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index ecef7950a..69249ed57 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -539,6 +539,8 @@ class LibvirtConnection(object): with LibvirtConnection._image_sems[fname]: if not os.path.exists(base): fn(target=base, *args, **kwargs) + if not LibvirtConnection._image_sems[fname].locked(): + del LibvirtConnection._image_sems[fname] if cow: utils.execute('qemu-img create -f qcow2 -o ' -- cgit From e502ad0243962aca98cc28bfa5cf69f8cd08991c Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Wed, 9 Mar 2011 21:43:45 -0500 Subject: Moved umount container to disk.py and try to remove loopback when destroying the container --- nova/virt/disk.py | 8 ++++++++ nova/virt/libvirt_conn.py | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index e1b0171b5..484317dd8 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -140,6 +140,14 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): utils.execute('sudo kpartx -s %s' % device) _unlink_device(device, nbd) +def destroy_container(target, instance, nbd=False): + """Destroy the container once it terminates""" + try: + utils.execute('sudo umount %s/rootfs' % target) + image = os.path.join(FLAGS.instances_path, instance['name'], '' + 'disk') + except Exception as e: + LOG.warn(_('Unable to umount contianer')) + def _link_device(image, nbd): """Link image to device using loopback or nbd""" if nbd: diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 97997513b..ef0eb20cd 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -260,7 +260,7 @@ class LibvirtConnection(object): LOG.info(_('instance %(instance_name)s: deleting instance files' ' %(target)s') % locals()) if FLAGS.libvirt_type == 'lxc': - utils.execute('sudo umount %s/rootfs' % target) + disk.destroy_container(target, instance, nbd=FLAGS.use_cow_images) if os.path.exists(target): shutil.rmtree(target) -- cgit From f0bb6d9fc47b92d335c7d7fa238dfd43f0dbdf69 Mon Sep 17 00:00:00 2001 From: Kei Masumoto Date: Thu, 10 Mar 2011 13:30:52 +0900 Subject: fixed based on reviewer's comment. --- nova/virt/libvirt_conn.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 938719a7c..43a9dc4e7 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -860,7 +860,14 @@ class LibvirtConnection(object): """ - return multiprocessing.cpu_count() + # On certain platforms, this will raise a NotImplementedError. + try: + return multiprocessing.cpu_count() + except NotImplementedError: + LOG.warn(_("Cannot get the number of cpu, because this " + "function is not implemented for this platform. " + "This error can be safely ignored for now.")) + return 0 def get_memory_mb_total(self): """Get the total memory size(MB) of physical computer. @@ -1042,9 +1049,9 @@ class LibvirtConnection(object): try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: - msg = _(("""Cannot update compute manager specific info,""" - """ Because no service record found.""")) - raise exception.Invalid(msg) + raise exception.Invalid(_("Cannot update compute manager " + "specific info, because no service " + "record was found.")) # Updating host information dic = {'vcpus': self.get_vcpu_total(), @@ -1059,11 +1066,11 @@ class LibvirtConnection(object): compute_node_ref = service_ref['compute_node'] if not compute_node_ref: - LOG.info(_('Compute_service record is created for %s ') % host) + LOG.info(_('Compute_service record created for %s ') % host) dic['service_id'] = service_ref['id'] db.compute_node_create(ctxt, dic) else: - LOG.info(_('Compute_service record is updated for %s ') % host) + LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic) def compare_cpu(self, cpu_info): @@ -1081,8 +1088,7 @@ class LibvirtConnection(object): """ - LOG.info(_('Checking cpu_info: instance was launched this cpu.\n%s') - % cpu_info) + LOG.info(_('Instance launched has CPU info:\n%s') % cpu_info) dic = utils.loads(cpu_info) xml = str(Template(self.cpuinfo_xml, searchList=dic)) LOG.info(_('to xml...\n:%s ' % xml)) -- cgit From 1fa41c5c621f3190c8c2b1c3d885c95b6b627b23 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 10 Mar 2011 09:52:19 +0100 Subject: s/s.getuid()/os.getuid()/ --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e25e4af4f..44b07213a 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -463,7 +463,7 @@ class LibvirtConnection(object): console_log = os.path.join(FLAGS.instances_path, instance['name'], 'console.log') - utils.execute('sudo', 'chown', s.getuid(), console_log) + utils.execute('sudo', 'chown', os.getuid(), console_log) if FLAGS.libvirt_type == 'xen': # Xen is special -- cgit From b38af111532717cbe9f4bef1d3c3d58e7082c8b9 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 10 Mar 2011 16:25:18 +0100 Subject: Another little detail.. --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index a54cda003..5d499c42c 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -51,7 +51,7 @@ def extend(image, size): return utils.execute('truncate', '-s', size, image) # NOTE(vish): attempts to resize filesystem - utils.execute('e2fsck', '-fp', mage, check_exit_code=False) + utils.execute('e2fsck', '-fp', image, check_exit_code=False) utils.execute('resize2fs', image, check_exit_code=False) -- cgit From 3e97dc47221d19b39aba99f6d389d2ec326e72be Mon Sep 17 00:00:00 2001 From: sateesh Date: Thu, 10 Mar 2011 21:07:44 +0530 Subject: Updated the code to detect the exception by fault type. SOAP faults are embedded in the SOAP response as a property. Certain faults are sent as a part of the SOAP body as property of missingSet. E.g. NotAuthenticated fault. So we examine the response object for missingSet and try to check the property for fault type. --- nova/virt/vmwareapi/error_util.py | 82 ++++++++++++++++++++++++++++++++++++ nova/virt/vmwareapi/fake.py | 13 +++--- nova/virt/vmwareapi/network_utils.py | 44 +++++++++++++------ nova/virt/vmwareapi/vim.py | 69 ++++++++++++++---------------- nova/virt/vmwareapi/vmops.py | 13 ++++-- nova/virt/vmwareapi_conn.py | 23 ++++++---- 6 files changed, 177 insertions(+), 67 deletions(-) create mode 100644 nova/virt/vmwareapi/error_util.py (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/error_util.py b/nova/virt/vmwareapi/error_util.py new file mode 100644 index 000000000..3196b5038 --- /dev/null +++ b/nova/virt/vmwareapi/error_util.py @@ -0,0 +1,82 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Exception classes and SOAP response error checking module +""" + +FAULT_NOT_AUTHENTICATED = "NotAuthenticated" +FAULT_ALREADY_EXISTS = "AlreadyExists" + + +class VimException(Exception): + """The VIM Exception class""" + + def __init__(self, exception_summary, excep): + Exception.__init__(self) + self.exception_summary = exception_summary + self.exception_obj = excep + + def __str__(self): + return self.exception_summary + str(self.exception_obj) + + +class SessionOverLoadException(VimException): + """Session Overload Exception""" + pass + + +class VimAttributeError(VimException): + """VI Attribute Error""" + pass + + +class VimFaultException(Exception): + """The VIM Fault exception class""" + + def __init__(self, fault_list, excep): + Exception.__init__(self) + self.fault_list = fault_list + self.exception_obj = excep + + def __str__(self): + return str(self.exception_obj) + + +class FaultCheckers: + """Methods for fault checking of SOAP response. Per Method error handlers + for which we desire error checking are defined. SOAP faults are + embedded in the SOAP as a property and not as a SOAP fault.""" + + @classmethod + def retrieveproperties_fault_checker(self, resp_obj): + """Checks the RetrieveProperties response for errors. Certain faults + are sent as a part of the SOAP body as property of missingSet. + For example NotAuthenticated fault""" + fault_list = [] + for obj_cont in resp_obj: + if hasattr(obj_cont, "missingSet"): + for missing_elem in obj_cont.missingSet: + fault_type = missing_elem.fault.fault.__class__.__name__ + #Fault needs to be added to the type of fault for + #uniformity in error checking as SOAP faults define + fault_list.append(fault_type) + if fault_list: + exc_msg_list = ', '.join(fault_list) + raise VimFaultException(fault_list, Exception(_("Error(s) %s " + "occurred in the call to RetrieveProperties") % + exc_msg_list)) diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py index 40ed18340..909d1a6cf 100644 --- a/nova/virt/vmwareapi/fake.py +++ b/nova/virt/vmwareapi/fake.py @@ -25,7 +25,7 @@ import uuid from nova import exception from nova import log as logging from nova.virt.vmwareapi import vim -from nova.virt.vmwareapi.vim import SessionFaultyException +from nova.virt.vmwareapi import error_util _CLASSES = ['Datacenter', 'Datastore', 'ResourcePool', 'VirtualMachine', 'Network', 'HostSystem', 'HostNetworkSystem', 'Task', 'session', @@ -500,7 +500,7 @@ class FakeVim(object): "out: %s") % s) del _db_content['session'][s] - def _terminate(self, *args, **kwargs): + def _terminate_session(self, *args, **kwargs): """ Terminates a session """ s = kwargs.get("sessionId")[0] if s not in _db_content['session']: @@ -512,7 +512,9 @@ class FakeVim(object): if (self._session is None or self._session not in _db_content['session']): LOG.debug(_("Session is faulty")) - raise SessionFaultyException(_("Session Invalid")) + raise error_util.VimFaultException( + [error_util.FAULT_NOT_AUTHENTICATED], + _("Session Invalid")) def _create_vm(self, method, *args, **kwargs): """ Creates and registers a VM object with the Host System """ @@ -656,8 +658,9 @@ class FakeVim(object): return lambda *args, **kwargs: self._login() elif attr_name == "Logout": self._logout() - elif attr_name == "Terminate": - return lambda *args, **kwargs: self._terminate(*args, **kwargs) + elif attr_name == "TerminateSession": + return lambda *args, **kwargs: self._terminate_session( + *args, **kwargs) elif attr_name == "CreateVM_Task": return lambda *args, **kwargs: self._create_vm(attr_name, *args, **kwargs) diff --git a/nova/virt/vmwareapi/network_utils.py b/nova/virt/vmwareapi/network_utils.py index 59a3c234f..f27121071 100644 --- a/nova/virt/vmwareapi/network_utils.py +++ b/nova/virt/vmwareapi/network_utils.py @@ -20,15 +20,12 @@ Utility functions for ESX Networking """ from nova import log as logging +from nova.virt.vmwareapi import error_util from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi import vm_util -from nova.virt.vmwareapi.vim import VimException LOG = logging.getLogger("nova.virt.vmwareapi.network_utils") -PORT_GROUP_EXISTS_EXCEPTION = \ - 'The specified key, name, or identifier already exists.' - class NetworkHelper: @@ -38,7 +35,13 @@ class NetworkHelper: argument. """ datacenters = session._call_method(vim_util, "get_objects", "Datacenter", ["network"]) - vm_networks = datacenters[0].propSet[0].val.ManagedObjectReference + vm_networks_ret = datacenters[0].propSet[0].val + #Meaning there are no networks on the host. suds responds with a "" + #in the parent property field rather than a [] in the + #ManagedObjectRefernce property field of the parent + if not vm_networks_ret: + return None + vm_networks = vm_networks_ret.ManagedObjectReference networks = session._call_method(vim_util, "get_properites_for_a_collection_of_objects", "Network", vm_networks, ["summary.name"]) @@ -54,9 +57,14 @@ class NetworkHelper: #Get the list of vSwicthes on the Host System host_mor = session._call_method(vim_util, "get_objects", "HostSystem")[0].obj - vswitches = session._call_method(vim_util, + vswitches_ret = session._call_method(vim_util, "get_dynamic_property", host_mor, - "HostSystem", "config.network.vswitch").HostVirtualSwitch + "HostSystem", "config.network.vswitch") + #Meaning there are no vSwitches on the host. Shouldn't be the case, + #but just doing code check + if not vswitches_ret: + return + vswitches = vswitches_ret.HostVirtualSwitch #Get the vSwitch associated with the network adapter for elem in vswitches: try: @@ -71,9 +79,13 @@ class NetworkHelper: """ Checks if the vlan_inteface exists on the esx host """ host_net_system_mor = session._call_method(vim_util, "get_objects", "HostSystem", ["configManager.networkSystem"])[0].propSet[0].val - physical_nics = session._call_method(vim_util, + physical_nics_ret = session._call_method(vim_util, "get_dynamic_property", host_net_system_mor, - "HostNetworkSystem", "networkInfo.pnic").PhysicalNic + "HostNetworkSystem", "networkInfo.pnic") + #Meaning there are no physical nics on the host + if not physical_nics_ret: + return False + physical_nics = physical_nics_ret.PhysicalNic for pnic in physical_nics: if vlan_interface == pnic.device: return True @@ -84,9 +96,15 @@ class NetworkHelper: """ Get the vlan id and vswicth associated with the port group """ host_mor = session._call_method(vim_util, "get_objects", "HostSystem")[0].obj - port_grps_on_host = session._call_method(vim_util, + port_grps_on_host_ret = session._call_method(vim_util, "get_dynamic_property", host_mor, - "HostSystem", "config.network.portgroup").HostPortGroup + "HostSystem", "config.network.portgroup") + if not port_grps_on_host_ret: + excep = ("ESX SOAP server returned an empty port group " + "for the host system in its response") + LOG.exception(excep) + raise Exception(_(excep)) + port_grps_on_host = port_grps_on_host_ret.HostPortGroup for p_gp in port_grps_on_host: if p_gp.spec.name == pg_name: p_grp_vswitch_name = p_gp.vswitch.split("-")[-1] @@ -113,13 +131,13 @@ class NetworkHelper: session._call_method(session._get_vim(), "AddPortGroup", network_system_mor, portgrp=add_prt_grp_spec) - except VimException, exc: + except error_util.VimFaultException, exc: #There can be a race condition when two instances try #adding port groups at the same time. One succeeds, then #the other one will get an exception. Since we are #concerned with the port group being created, which is done #by the other call, we can ignore the exception. - if str(exc).find(PORT_GROUP_EXISTS_EXCEPTION) == -1: + if error_util.FAULT_ALREADY_EXISTS not in exc.fault_list: raise Exception(exc) LOG.debug(_("Created Port Group with name %s on " "the ESX host") % pg_name) diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index 6a3e4b376..cea65e198 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -21,11 +21,13 @@ Classes for making VMware VI SOAP calls import httplib +from suds import WebFault from suds.client import Client from suds.plugin import MessagePlugin from suds.sudsobject import Property from nova import flags +from nova.virt.vmwareapi import error_util RESP_NOT_XML_ERROR = 'Response is "text/html", not "text/xml' CONN_ABORT_ERROR = 'Software caused connection abort' @@ -40,33 +42,6 @@ flags.DEFINE_string('vmwareapi_wsdl_loc', 'Read the readme for vmware to setup') -class VimException(Exception): - """The VIM Exception class""" - - def __init__(self, exception_summary, excep): - Exception.__init__(self) - self.exception_summary = exception_summary - self.exception_obj = excep - - def __str__(self): - return self.exception_summary + str(self.exception_obj) - - -class SessionOverLoadException(VimException): - """Session Overload Exception""" - pass - - -class SessionFaultyException(VimException): - """Session Faulty Exception""" - pass - - -class VimAttributeError(VimException): - """VI Attribute Error""" - pass - - class VIMMessagePlugin(MessagePlugin): def addAttributeForValue(self, node): @@ -133,29 +108,49 @@ class Vim: request_mo = \ self._request_managed_object_builder(managed_object) request = getattr(self.client.service, attr_name) - return request(request_mo, **kwargs) + response = request(request_mo, **kwargs) + #To check for the faults that are part of the message body + #and not returned as Fault object response from the ESX + #SOAP server + if hasattr(error_util.FaultCheckers, + attr_name.lower() + "_fault_checker"): + fault_checker = getattr(error_util.FaultCheckers, + attr_name.lower() + "_fault_checker") + fault_checker(response) + return response + #Catch the VimFaultException that is raised by the fault + #check of the SOAP response + except error_util.VimFaultException, excep: + raise + except WebFault, excep: + doc = excep.document + detail = doc.childAtPath("/Envelope/Body/Fault/detail") + fault_list = [] + for child in detail.getChildren(): + fault_list.append(child.get("type")) + raise error_util.VimFaultException(fault_list, excep) except AttributeError, excep: - raise VimAttributeError(_("No such SOAP method '%s'" - " provided by VI SDK") % (attr_name), excep) + raise error_util.VimAttributeError(_("No such SOAP method " + "'%s' provided by VI SDK") % (attr_name), excep) except (httplib.CannotSendRequest, httplib.ResponseNotReady, httplib.CannotSendHeader), excep: - raise SessionOverLoadException(_("httplib error in" - " %s: ") % (attr_name), excep) + raise error_util.SessionOverLoadException(_("httplib " + "error in %s: ") % (attr_name), excep) except Exception, excep: # Socket errors which need special handling for they # might be caused by ESX API call overload if (str(excep).find(ADDRESS_IN_USE_ERROR) != -1 or str(excep).find(CONN_ABORT_ERROR)) != -1: - raise SessionOverLoadException(_("Socket error in" - " %s: ") % (attr_name), excep) + raise error_util.SessionOverLoadException(_("Socket " + "error in %s: ") % (attr_name), excep) # Type error that needs special handling for it might be # caused by ESX host API call overload elif str(excep).find(RESP_NOT_XML_ERROR) != -1: - raise SessionOverLoadException(_("Type error in " - " %s: ") % (attr_name), excep) + raise error_util.SessionOverLoadException(_("Type " + "error in %s: ") % (attr_name), excep) else: - raise VimException( + raise error_util.VimException( _("Exception in %s ") % (attr_name), excep) return vim_request_handler diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index 524c35af5..344c4518b 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -373,10 +373,15 @@ class VMWareVMOps(object): def _check_if_tmp_folder_exists(): #Copy the contents of the VM that were there just before the #snapshot was taken - ds_ref = vim_util.get_dynamic_property(self._session._get_vim(), - vm_ref, - "VirtualMachine", - "datastore").ManagedObjectReference[0] + ds_ref_ret = vim_util.get_dynamic_property( + self._session._get_vim(), + vm_ref, + "VirtualMachine", + "datastore") + if not ds_ref_ret: + raise Exception(_("Failed to get the datastore reference(s) " + "which the VM uses")) + ds_ref = ds_ref_ret.ManagedObjectReference[0] ds_browser = vim_util.get_dynamic_property( self._session._get_vim(), ds_ref, diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index bd3ab4320..a2609278d 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -40,6 +40,7 @@ from nova import db from nova import flags from nova import log as logging from nova import utils +from nova.virt.vmwareapi import error_util from nova.virt.vmwareapi import vim from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi.vmops import VMWareVMOps @@ -60,7 +61,7 @@ flags.DEFINE_string('vmwareapi_host_password', 'Password for connection to VMWare ESX host.' 'Used only if connection_type is vmwareapi.') flags.DEFINE_float('vmwareapi_task_poll_interval', - 1.0, + 5.0, 'The interval used for polling of remote tasks ' 'Used only if connection_type is vmwareapi') flags.DEFINE_float('vmwareapi_api_retry_count', @@ -264,13 +265,19 @@ class VMWareAPISession(object): ret_val = temp_module(*args, **kwargs) return ret_val - except vim.SessionFaultyException, excep: + except error_util.VimFaultException, excep: # If it is a Session Fault Exception, it may point # to a session gone bad. So we try re-creating a session # and then proceeding ahead with the call. exc = excep - self._create_session() - except vim.SessionOverLoadException, excep: + if error_util.FAULT_NOT_AUTHENTICATED in excep.fault_list: + self._create_session() + else: + #No re-trying for errors for API call has gone through + #and is the caller's fault. Caller should handle these + #errors. e.g, InvalidArgument fault. + break + except error_util.SessionOverLoadException, excep: # For exceptions which may come because of session overload, # we retry exc = excep @@ -288,7 +295,7 @@ class VMWareAPISession(object): LOG.critical(_("In vmwareapi:_call_method, " "got this exception: %s") % exc) - raise Exception(exc) + raise def _get_vim(self): """Gets the VIM object reference""" @@ -301,11 +308,11 @@ class VMWareAPISession(object): The task is polled until it completes. """ done = event.Event() - self.loop = utils.LoopingCall(self._poll_task, instance_id, task_ref, + loop = utils.LoopingCall(self._poll_task, instance_id, task_ref, done) - self.loop.start(FLAGS.vmwareapi_task_poll_interval, now=True) + loop.start(FLAGS.vmwareapi_task_poll_interval, now=True) ret_val = done.wait() - self.loop.stop() + loop.stop() return ret_val def _poll_task(self, instance_id, task_ref, done): -- cgit From 801212a0ff04ddc33719d17b8c8ca847db5b1228 Mon Sep 17 00:00:00 2001 From: Cory Wright Date: Thu, 10 Mar 2011 15:47:55 +0000 Subject: Use a FLAGS.default_os_type if available --- nova/virt/xenapi/vm_utils.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index a1b85284f..8dd246178 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -41,9 +41,11 @@ from nova.virt.xenapi import HelperBase from nova.virt.xenapi.volume_utils import StorageError -FLAGS = flags.FLAGS LOG = logging.getLogger("nova.virt.xenapi.vm_utils") +FLAGS = flags.FLAGS +flags.DEFINE_string('default_os_type', 'linux', 'Default OS type') + XENAPI_POWER_STATE = { 'Halted': power_state.SHUTDOWN, 'Running': power_state.RUNNING, @@ -347,7 +349,7 @@ class VMHelper(HelperBase): logging.debug(_("Asking xapi to upload %(vdi_uuids)s as" " ID %(image_id)s") % locals()) - os_type = instance.os_type and instance.os_type or 'linux' + os_type = instance.os_type or FLAGS.default_os_type params = {'vdi_uuids': vdi_uuids, 'image_id': image_id, -- cgit From 4ead485ab69ee1e92635857ba73133a9e1d3bbcb Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 10 Mar 2011 12:06:09 -0600 Subject: Cleaned up vmops --- nova/virt/xenapi/vm_utils.py | 26 +++++------ nova/virt/xenapi/vmops.py | 104 ++++++++++++++++++++----------------------- 2 files changed, 61 insertions(+), 69 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index ce081a2d6..4ad820bcd 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -90,7 +90,7 @@ class VMHelper(HelperBase): get_instance_type(instance.instance_type) mem = str(long(instance_type['memory_mb']) * 1024 * 1024) vcpus = str(instance_type['vcpus']) - rec = { + vm_rec = { 'name_label': instance.name, 'name_description': '', 'is_a_template': False, @@ -122,23 +122,23 @@ class VMHelper(HelperBase): #Complete VM configuration record according to the image type #non-raw/raw with PV kernel/raw in HVM mode if instance.kernel_id: - rec['PV_bootloader'] = '' - rec['PV_kernel'] = kernel - rec['PV_ramdisk'] = ramdisk - rec['PV_args'] = 'root=/dev/xvda1' - rec['PV_bootloader_args'] = '' - rec['PV_legacy_args'] = '' + vm_rec['PV_bootloader'] = '' + vm_rec['PV_kernel'] = kernel + vm_rec['PV_ramdisk'] = ramdisk + vm_rec['PV_args'] = 'root=/dev/xvda1' + vm_rec['PV_bootloader_args'] = '' + vm_rec['PV_legacy_args'] = '' else: if pv_kernel: - rec['PV_args'] = 'noninteractive' - rec['PV_bootloader'] = 'pygrub' + vm_rec['PV_args'] = 'noninteractive' + vm_rec['PV_bootloader'] = 'pygrub' else: - rec['HVM_boot_policy'] = 'BIOS order' - rec['HVM_boot_params'] = {'order': 'dc'} - rec['platform'] = {'acpi': 'true', 'apic': 'true', + vm_rec['HVM_boot_policy'] = 'BIOS order' + vm_rec['HVM_boot_params'] = {'order': 'dc'} + vm_rec['platform'] = {'acpi': 'true', 'apic': 'true', 'pae': 'true', 'viridian': 'true'} LOG.debug(_('Created VM %s...'), instance.name) - vm_ref = session.call_xenapi('VM.create', rec) + vm_ref = session.call_xenapi('VM.create', vm_rec) instance_name = instance.name LOG.debug(_('Created VM %(instance_name)s as %(vm_ref)s.') % locals()) return vm_ref diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 562ecd4d5..5375df5b4 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -56,10 +56,10 @@ class VMOps(object): def list_instances(self): """List VM instances""" vms = [] - for vm in self._session.get_xenapi().VM.get_all(): - rec = self._session.get_xenapi().VM.get_record(vm) - if not rec["is_a_template"] and not rec["is_control_domain"]: - vms.append(rec["name_label"]) + for vm_ref in self._session.get_xenapi().VM.get_all(): + vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) + if not vm_rec["is_a_template"] and not vm_rec["is_control_domain"]: + vms.append(vm_rec["name_label"]) return vms def _start(self, instance, vm_ref=None): @@ -371,8 +371,8 @@ class VMOps(object): def reboot(self, instance): """Reboot VM instance""" - vm = self._get_vm_opaque_ref(instance) - task = self._session.call_xenapi('Async.VM.clean_reboot', vm) + vm_ref = self._get_vm_opaque_ref(instance) + task = self._session.call_xenapi('Async.VM.clean_reboot', vm_ref) self._session.wait_for_task(task, instance.id) def set_admin_password(self, instance, new_pass): @@ -571,26 +571,27 @@ class VMOps(object): def pause(self, instance, callback): """Pause VM instance""" - vm = self._get_vm_opaque_ref(instance) - task = self._session.call_xenapi('Async.VM.pause', vm) + vm_ref = self._get_vm_opaque_ref(instance) + task = self._session.call_xenapi('Async.VM.pause', vm_ref) self._wait_with_callback(instance.id, task, callback) def unpause(self, instance, callback): """Unpause VM instance""" - vm = self._get_vm_opaque_ref(instance) - task = self._session.call_xenapi('Async.VM.unpause', vm) + vm_ref = self._get_vm_opaque_ref(instance) + task = self._session.call_xenapi('Async.VM.unpause', vm_ref) self._wait_with_callback(instance.id, task, callback) def suspend(self, instance, callback): """suspend the specified instance""" - vm = self._get_vm_opaque_ref(instance) - task = self._session.call_xenapi('Async.VM.suspend', vm) + vm_ref = self._get_vm_opaque_ref(instance) + task = self._session.call_xenapi('Async.VM.suspend', vm_ref) self._wait_with_callback(instance.id, task, callback) def resume(self, instance, callback): """resume the specified instance""" - vm = self._get_vm_opaque_ref(instance) - task = self._session.call_xenapi('Async.VM.resume', vm, False, True) + vm_ref = self._get_vm_opaque_ref(instance) + task = self._session.call_xenapi('Async.VM.resume', vm_ref, False, + True) self._wait_with_callback(instance.id, task, callback) def rescue(self, instance, callback): @@ -605,22 +606,18 @@ class VMOps(object): raise RuntimeError(_( "Instance is already in Rescue Mode: %s" % instance.name)) - vm = self._get_vm_opaque_ref(instance) - self._shutdown(instance, vm) - self._acquire_bootlock(vm) + vm_ref = self._get_vm_opaque_ref(instance) + self._shutdown(instance, vm_ref) + self._acquire_bootlock(vm_ref) instance._rescue = True self.spawn(instance) - rescue_vm = self._get_vm_opaque_ref(instance) + rescue_vm_ref = self._get_vm_opaque_ref(instance) - vbd = self._session.get_xenapi().VM.get_VBDs(vm)[0] + vbd = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0] vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] - vbd_ref = VMHelper.create_vbd( - self._session, - rescue_vm, - vdi_ref, - 1, - False) + vbd_ref = VMHelper.create_vbd(self._session, rescue_vm_ref, vdi_ref, + 1, False) self._session.call_xenapi("Async.VBD.plug", vbd_ref) @@ -637,7 +634,7 @@ class VMOps(object): raise exception.NotFound(_( "Instance is not in Rescue Mode: %s" % instance.name)) - original_vm = self._get_vm_opaque_ref(instance) + original_vm_ref = self._get_vm_opaque_ref(instance) vbds = self._session.get_xenapi().VM.get_VBDs(rescue_vm) instance._rescue = False @@ -662,20 +659,20 @@ class VMOps(object): task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm) self._session.wait_for_task(task2, instance.id) - self._release_bootlock(original_vm) - self._start(instance, original_vm) + self._release_bootlock(original_vm_ref) + self._start(instance, original_vm_ref) def get_info(self, instance): """Return data about VM instance""" - vm = self._get_vm_opaque_ref(instance) - rec = self._session.get_xenapi().VM.get_record(vm) - return VMHelper.compile_info(rec) + vm_ref = self._get_vm_opaque_ref(instance) + vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) + return VMHelper.compile_info(vm_rec) def get_diagnostics(self, instance): """Return data about VM diagnostics""" - vm = self._get_vm_opaque_ref(instance) - rec = self._session.get_xenapi().VM.get_record(vm) - return VMHelper.compile_diagnostics(self._session, rec) + vm_ref = self._get_vm_opaque_ref(instance) + vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) + return VMHelper.compile_diagnostics(self._session, vm_rec) def get_console_output(self, instance): """Return snapshot of console""" @@ -698,9 +695,9 @@ class VMOps(object): # at this stage even though they aren't implemented because these will # be needed for multi-nic and there was no sense writing it for single # network/single IP and then having to turn around and re-write it - vm_opaque_ref = self._get_vm_opaque_ref(instance.id) + vm_ref = self._get_vm_opaque_ref(instance.id) logging.debug(_("injecting network info to xenstore for vm: |%s|"), - vm_opaque_ref) + vm_ref) admin_context = context.get_admin_context() IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) networks = db.network_get_all_by_instance(admin_context, @@ -731,11 +728,10 @@ class VMOps(object): 'ips': [ip_dict(ip) for ip in network_IPs], 'ip6s': [ip6_dict(ip) for ip in network_IPs]} - self.write_to_param_xenstore(vm_opaque_ref, {location: mapping}) + self.write_to_param_xenstore(vm_ref, {location: mapping}) try: - self.write_to_xenstore(vm_opaque_ref, location, - mapping['location']) + self.write_to_xenstore(vm_ref, location, mapping['location']) except KeyError: # catch KeyError for domid if instance isn't running pass @@ -747,8 +743,8 @@ class VMOps(object): Creates vifs for an instance """ - vm_opaque_ref = self._get_vm_opaque_ref(instance.id) - logging.debug(_("creating vif(s) for vm: |%s|"), vm_opaque_ref) + vm_ref = self._get_vm_opaque_ref(instance.id) + logging.debug(_("creating vif(s) for vm: |%s|"), vm_ref) if networks is None: networks = db.network_get_all_by_instance(admin_context, instance['id']) @@ -768,12 +764,8 @@ class VMOps(object): except AttributeError: device = "0" - VMHelper.create_vif( - self._session, - vm_opaque_ref, - network_ref, - instance.mac_address, - device) + VMHelper.create_vif(self._session, vm_ref, network_ref, + instance.mac_address, device) def reset_network(self, instance): """ @@ -837,9 +829,9 @@ class VMOps(object): Any errors raised by the plugin will in turn raise a RuntimeError here. """ instance_id = vm.id - vm = self._get_vm_opaque_ref(vm) - rec = self._session.get_xenapi().VM.get_record(vm) - args = {'dom_id': rec['domid'], 'path': path} + vm_ref = self._get_vm_opaque_ref(vm) + vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) + args = {'dom_id': vm_rec['domid'], 'path': path} args.update(addl_args) try: task = self._session.async_call_plugin(plugin, method, args) @@ -919,9 +911,9 @@ class VMOps(object): value for 'keys' is passed, the returned dict is filtered to only return the values for those keys. """ - vm = self._get_vm_opaque_ref(instance_or_vm) + vm_ref = self._get_vm_opaque_ref(instance_or_vm) data = self._session.call_xenapi_request('VM.get_xenstore_data', - (vm, )) + (vm_ref, )) ret = {} if keys is None: keys = data.keys() @@ -939,11 +931,11 @@ class VMOps(object): """Takes a key/value pair and adds it to the xenstore parameter record for the given vm instance. If the key exists in xenstore, it is overwritten""" - vm = self._get_vm_opaque_ref(instance_or_vm) + vm_ref = self._get_vm_opaque_ref(instance_or_vm) self.remove_from_param_xenstore(instance_or_vm, key) jsonval = json.dumps(val) self._session.call_xenapi_request('VM.add_to_xenstore_data', - (vm, key, jsonval)) + (vm_ref, key, jsonval)) def write_to_param_xenstore(self, instance_or_vm, mapping): """Takes a dict and writes each key/value pair to the xenstore @@ -958,14 +950,14 @@ class VMOps(object): them from the xenstore parameter record data for the given VM. If the key doesn't exist, the request is ignored. """ - vm = self._get_vm_opaque_ref(instance_or_vm) + vm_ref = self._get_vm_opaque_ref(instance_or_vm) if isinstance(key_or_keys, basestring): keys = [key_or_keys] else: keys = key_or_keys for key in keys: self._session.call_xenapi_request('VM.remove_from_xenstore_data', - (vm, key)) + (vm_ref, key)) def clear_param_xenstore(self, instance_or_vm): """Removes all data from the xenstore parameter record for this VM.""" -- cgit From 4a9f4f4eef4e6fd6ab84ec2e03437144f9ab62f8 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 10 Mar 2011 16:07:50 -0600 Subject: More resize --- nova/virt/xenapi/vmops.py | 13 +++++++++++-- nova/virt/xenapi_conn.py | 9 +++++---- 2 files changed, 16 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 562ecd4d5..9e0bd6a75 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -365,9 +365,18 @@ class VMOps(object): return new_cow_uuid - def resize(self, instance, flavor): + def resize_instance(self, instance, vdi_uuid): """Resize a running instance by changing it's RAM and disk size """ - raise NotImplementedError() + vm_ref = VMHelper.lookup(self._session, instance.name) + vdi_ref, vm_vdi_rec = \ + VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) + new_disk_size = instance.local_gb + + #TODO(mdietz): this will need to be adjusted for swap later + task = self._session.call_xenapi('VDI.resize_online', vdi_ref, + new_disk_size) + vm_ref = VMHelper.lookup(self._session, instance.name) + self._session.wait_for_task(task, instance.id) def reboot(self, instance): """Reboot VM instance""" diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index b63a5f8c3..92b262479 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -158,6 +158,11 @@ class XenAPIConnection(object): """Create VM instance""" self._vmops.spawn(instance) + def resize_instance(self, instance, disk_info): + """Resizes instance attributes such as RAM and disk space to the + attributes specified by the record""" + self._vmops.resize_instance(instance, disk_info['cow']) + def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" vdi_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], @@ -168,10 +173,6 @@ class XenAPIConnection(object): """ Create snapshot from a running VM instance """ self._vmops.snapshot(instance, image_id) - def resize(self, instance, flavor): - """Resize a VM instance""" - raise NotImplementedError() - def reboot(self, instance): """Reboot VM instance""" self._vmops.reboot(instance) -- cgit From 46d1f6a8c888c1f6fdf12cf26df67eada1e8505b Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Fri, 11 Mar 2011 11:24:22 +0100 Subject: Use self.instances.pop in unfilter_instance to make the check/removal atomic. Move the semaphore grab outside the for loop in refresh_security_group_rules to avoid reading a value from self.instances, blocking waiting for the semaphore, having the instance be removed in the mean time, and then add its rules back. --- nova/virt/libvirt_conn.py | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index b74ed25f9..d82b33ddd 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1238,13 +1238,12 @@ class IptablesFirewallDriver(FirewallDriver): pass def unfilter_instance(self, instance): - if instance['id'] in self.instances: - del self.instances[instance['id']] + if self.instances.pop(instance['id'], False): self.remove_filters_for_instance(instance) self.iptables.apply() else: LOG.info(_('Attempted to unfilter instance %s which is not ' - 'filtered'), instance['id']) + 'filtered'), instance['id']) def prepare_instance_filter(self, instance): self.instances[instance['id']] = instance @@ -1387,11 +1386,11 @@ class IptablesFirewallDriver(FirewallDriver): pass def refresh_security_group_rules(self, security_group): - for instance in self.instances.values(): - # We use the semaphore to make sure noone applies the rule set - # after we've yanked the existing rules but before we've put in - # the new ones. - with self.iptables.semaphore: + # We use the semaphore to make sure noone applies the rule set + # after we've yanked the existing rules but before we've put in + # the new ones. + with self.iptables.semaphore: + for instance in self.instances.values(): self.remove_filters_for_instance(instance) self.add_filters_for_instance(instance) self.iptables.apply() -- cgit From 977fc1be4ea8af93b63975c5538462a776fbe168 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Fri, 11 Mar 2011 11:42:42 +0000 Subject: Moved vlan_interface flag in network.manager removed needless carriage return in vm_ops --- nova/virt/xenapi/vmops.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 9140774c5..66df3c28e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -236,8 +236,7 @@ class VMOps(object): """Create snapshot from a running VM instance :param instance: instance to be snapshotted - :param image_id: id of - image to upload to + :param image_id: id of image to upload to Steps involved in a XenServer snapshot: -- cgit From 7f28cb611c6bc802ad78242275b18bb0278e43bd Mon Sep 17 00:00:00 2001 From: sateesh Date: Fri, 11 Mar 2011 20:02:21 +0530 Subject: * Modified raise statements to raise nova defined Exceptions. * Fixed Console errors and in network utils using HostSystem instead of Datacenter to fetch network list * Added support for vmwareapi module in nova/virt/connection.py so that vmware hypervisor is supported by nova * Removing self.loop to achieve synchronization --- nova/virt/connection.py | 5 +++- nova/virt/vmwareapi/fake.py | 32 +++++++++++++++--------- nova/virt/vmwareapi/network_utils.py | 11 +++++---- nova/virt/vmwareapi/vmops.py | 47 +++++++++++++++++++++--------------- nova/virt/vmwareapi/vmware_images.py | 5 ++-- nova/virt/vmwareapi_conn.py | 3 ++- 6 files changed, 62 insertions(+), 41 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/connection.py b/nova/virt/connection.py index 13181b730..8b950b430 100644 --- a/nova/virt/connection.py +++ b/nova/virt/connection.py @@ -24,9 +24,10 @@ import sys from nova import flags from nova import log as logging from nova.virt import fake +from nova.virt import hyperv from nova.virt import libvirt_conn +from nova.virt import vmwareapi_conn from nova.virt import xenapi_conn -from nova.virt import hyperv LOG = logging.getLogger("nova.virt.connection") @@ -66,6 +67,8 @@ def get_connection(read_only=False): conn = xenapi_conn.get_connection(read_only) elif t == 'hyperv': conn = hyperv.get_connection(read_only) + elif t == 'vmwareapi': + conn = vmwareapi_conn.get_connection(read_only) else: raise Exception('Unknown connection type "%s"' % t) diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py index 909d1a6cf..e03d74cf8 100644 --- a/nova/virt/vmwareapi/fake.py +++ b/nova/virt/vmwareapi/fake.py @@ -131,7 +131,7 @@ class ManagedObject(object): for elem in self.propSet: if elem.name == attr: return elem.val - raise Exception(_("Property %(attr)s not set for the managed " + raise exception.Error(_("Property %(attr)s not set for the managed " "object %(objName)s") % {'attr': attr, 'objName': self.objName}) @@ -272,6 +272,13 @@ class HostSystem(ManagedObject): host_net_sys = _db_content["HostNetworkSystem"][host_net_key].obj self.set("configManager.networkSystem", host_net_sys) + if _db_content.get("Network", None) is None: + create_network() + net_ref = _db_content["Network"][_db_content["Network"].keys()[0]].obj + network_do = DataObject() + network_do.ManagedObjectReference = [net_ref] + self.set("network", network_do) + vswitch_do = DataObject() vswitch_do.pnic = ["vmnic0"] vswitch_do.name = "vSwitch0" @@ -390,12 +397,12 @@ def _add_file(file_path): def _remove_file(file_path): """ Removes a file reference from the db """ if _db_content.get("files", None) is None: - raise Exception(_("No files have been added yet")) + raise exception.NotFound(_("No files have been added yet")) #Check if the remove is for a single file object or for a folder if file_path.find(".vmdk") != -1: if file_path not in _db_content.get("files"): - raise Exception(_("File- '%s' is not there in the datastore") %\ - file_path) + raise exception.NotFound(_("File- '%s' is not there in the " + "datastore") % file_path) _db_content.get("files").remove(file_path) else: #Removes the files in the folder and the folder too from the db @@ -430,10 +437,10 @@ def fake_get_vmdk_size_and_properties(image_id, instance): def _get_vm_mdo(vm_ref): """ Gets the Virtual Machine with the ref from the db """ if _db_content.get("VirtualMachine", None) is None: - raise Exception(_("There is no VM registered")) + raise exception.NotFound(_("There is no VM registered")) if vm_ref not in _db_content.get("VirtualMachine"): - raise Exception(_("Virtual Machine with ref %s is not there") %\ - vm_ref) + raise exception.NotFound(_("Virtual Machine with ref %s is not " + "there") % vm_ref) return _db_content.get("VirtualMachine")[vm_ref] @@ -584,7 +591,7 @@ class FakeVim(object): """ Searches the datastore for a file """ ds_path = kwargs.get("datastorePath") if _db_content.get("files", None) is None: - raise Exception(_("No files have been added yet")) + raise exception.NotFound(_("No files have been added yet")) for file in _db_content.get("files"): if file.find(ds_path) != -1: task_mdo = create_task(method, "success") @@ -596,16 +603,17 @@ class FakeVim(object): """ Creates a directory in the datastore """ ds_path = kwargs.get("name") if _db_content.get("files", None) is None: - raise Exception(_("No files have been added yet")) + raise exception.NotFound(_("No files have been added yet")) _db_content["files"].append(ds_path) def _set_power_state(self, method, vm_ref, pwr_state="poweredOn"): """ Sets power state for the VM """ if _db_content.get("VirtualMachine", None) is None: - raise Exception(_(" No Virtual Machine has been registered yet")) + raise exception.NotFound(_(" No Virtual Machine has been " + "registered yet")) if vm_ref not in _db_content.get("VirtualMachine"): - raise Exception(_("Virtual Machine with ref %s is not there") %\ - vm_ref) + raise exception.NotFound(_("Virtual Machine with ref %s is not " + "there") % vm_ref) vm_mdo = _db_content.get("VirtualMachine").get(vm_ref) vm_mdo.set("runtime.powerState", pwr_state) task_mdo = create_task(method, "success") diff --git a/nova/virt/vmwareapi/network_utils.py b/nova/virt/vmwareapi/network_utils.py index f27121071..36fa98996 100644 --- a/nova/virt/vmwareapi/network_utils.py +++ b/nova/virt/vmwareapi/network_utils.py @@ -19,6 +19,7 @@ Utility functions for ESX Networking """ +from nova import exception from nova import log as logging from nova.virt.vmwareapi import error_util from nova.virt.vmwareapi import vim_util @@ -33,9 +34,9 @@ class NetworkHelper: def get_network_with_the_name(cls, session, network_name="vmnet0"): """ Gets reference to the network whose name is passed as the argument. """ - datacenters = session._call_method(vim_util, "get_objects", - "Datacenter", ["network"]) - vm_networks_ret = datacenters[0].propSet[0].val + hostsystems = session._call_method(vim_util, "get_objects", + "HostSystem", ["network"]) + vm_networks_ret = hostsystems[0].propSet[0].val #Meaning there are no networks on the host. suds responds with a "" #in the parent property field rather than a [] in the #ManagedObjectRefernce property field of the parent @@ -103,7 +104,7 @@ class NetworkHelper: excep = ("ESX SOAP server returned an empty port group " "for the host system in its response") LOG.exception(excep) - raise Exception(_(excep)) + raise exception.Error(_(excep)) port_grps_on_host = port_grps_on_host_ret.HostPortGroup for p_gp in port_grps_on_host: if p_gp.spec.name == pg_name: @@ -138,6 +139,6 @@ class NetworkHelper: #concerned with the port group being created, which is done #by the other call, we can ignore the exception. if error_util.FAULT_ALREADY_EXISTS not in exc.fault_list: - raise Exception(exc) + raise exception.Error(exc) LOG.debug(_("Created Port Group with name %s on " "the ESX host") % pg_name) diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index 344c4518b..2d87a627d 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -100,8 +100,8 @@ class VMWareVMOps(object): """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref: - raise Exception(_("Attempted to create a VM with a name %s, " - "but that already exists on the host") % instance.name) + raise exception.Duplicate(_("Attempted to create a VM with a name" + " %s, but that already exists on the host") % instance.name) client_factory = self._session._get_vim().client.factory service_content = self._session._get_vim().get_service_content() @@ -116,8 +116,8 @@ class VMWareVMOps(object): NetworkHelper.get_network_with_the_name(self._session, net_name) if network_ref is None: - raise Exception(_("Network with the name '%s' doesn't exist on" - " the ESX host") % net_name) + raise exception.NotFound(_("Network with the name '%s' doesn't" + " exist on the ESX host") % net_name) _check_if_network_bridge_exists() @@ -141,7 +141,7 @@ class VMWareVMOps(object): if data_store_name is None: msg = _("Couldn't get a local Datastore reference") LOG.exception(msg) - raise Exception(msg) + raise exception.Error(msg) data_store_name = _get_datastore_ref() @@ -329,7 +329,8 @@ class VMWareVMOps(object): """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception(_("instance - %s not present") % instance.name) + raise exception.NotFound(_("instance - %s not present") % + instance.name) client_factory = self._session._get_vim().client.factory service_content = self._session._get_vim().get_service_content() @@ -379,8 +380,8 @@ class VMWareVMOps(object): "VirtualMachine", "datastore") if not ds_ref_ret: - raise Exception(_("Failed to get the datastore reference(s) " - "which the VM uses")) + raise exception.NotFound(_("Failed to get the datastore " + "reference(s) which the VM uses")) ds_ref = ds_ref_ret.ManagedObjectReference[0] ds_browser = vim_util.get_dynamic_property( self._session._get_vim(), @@ -467,7 +468,8 @@ class VMWareVMOps(object): """ Reboot a VM instance """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception(_("instance - %s not present") % instance.name) + raise exception.NotFound(_("instance - %s not present") % + instance.name) lst_properties = ["summary.guest.toolsStatus", "runtime.powerState"] props = self._session._call_method(vim_util, "get_object_properties", None, vm_ref, "VirtualMachine", @@ -483,8 +485,8 @@ class VMWareVMOps(object): #Raise an exception if the VM is not powered On. if pwr_state not in ["poweredOn"]: - raise Exception(_("instance - %s not poweredOn. So can't be " - "rebooted.") % instance.name) + raise exception.Invalid(_("instance - %s not poweredOn. So can't " + "be rebooted.") % instance.name) #If vmware tools are installed in the VM, then do a guest reboot. #Otherwise do a hard reset. @@ -585,7 +587,8 @@ class VMWareVMOps(object): """ Suspend the specified instance """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception(_("instance - %s not present") % instance.name) + raise exception.NotFound(_("instance - %s not present") % + instance.name) pwr_state = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, @@ -599,8 +602,8 @@ class VMWareVMOps(object): LOG.debug(_("Suspended the VM %s ") % instance.name) #Raise Exception if VM is poweredOff elif pwr_state == "poweredOff": - raise Exception(_("instance - %s is poweredOff and hence can't " - "be suspended.") % instance.name) + raise exception.Invalid(_("instance - %s is poweredOff and hence " + " can't be suspended.") % instance.name) LOG.debug(_("VM %s was already in suspended state. So returning " "without doing anything") % instance.name) @@ -608,7 +611,8 @@ class VMWareVMOps(object): """ Resume the specified instance """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception(_("instance - %s not present") % instance.name) + raise exception.NotFound(_("instance - %s not present") % + instance.name) pwr_state = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, @@ -621,14 +625,15 @@ class VMWareVMOps(object): self._wait_with_callback(instance.id, suspend_task, callback) LOG.debug(_("Resumed the VM %s ") % instance.name) else: - raise Exception(_("instance - %s not in Suspended state and hence " - "can't be Resumed.") % instance.name) + raise exception.Invalid(_("instance - %s not in Suspended state " + "and hence can't be Resumed.") % instance.name) def get_info(self, instance_name): """ Return data about the VM instance """ vm_ref = self._get_vm_ref_from_the_name(instance_name) if vm_ref is None: - raise Exception(_("instance - %s not present") % instance_name) + raise exception.NotFound(_("instance - %s not present") % + instance_name) lst_properties = ["summary.config.numCpu", "summary.config.memorySizeMB", @@ -664,7 +669,8 @@ class VMWareVMOps(object): """ Return snapshot of console """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception(_("instance - %s not present") % instance.name) + raise exception.NotFound(_("instance - %s not present") % + instance.name) param_list = {"id": str(vm_ref)} base_url = "%s://%s/screen?%s" % (self._session._scheme, self._session._host_ip, @@ -690,7 +696,8 @@ class VMWareVMOps(object): the IP """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: - raise Exception(_("instance - %s not present") % instance.name) + raise exception.NotFound(_("instance - %s not present") % + instance.name) network = db.network_get_by_instance(context.get_admin_context(), instance['id']) mac_addr = instance.mac_address diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py index f2a7c3b33..2b389987e 100644 --- a/nova/virt/vmwareapi/vmware_images.py +++ b/nova/virt/vmwareapi/vmware_images.py @@ -20,6 +20,7 @@ Utility functions for Image transfer import time +from nova import exception from nova import flags from nova import log as logging from nova.virt.vmwareapi import io_util @@ -58,10 +59,10 @@ def start_transfer(read_file_handle, write_file_handle, data_size): write_excep = write_thread.get_exception() if read_excep is not None: LOG.exception(str(read_excep)) - raise Exception(read_excep) + raise exception.Error(read_excep) if write_excep is not None: LOG.exception(str(write_excep)) - raise Exception(write_excep) + raise exception.Error(write_excep) time.sleep(2) LOG.debug(_("Finished image file transfer and closing the file handles")) #Close the file handles diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index a2609278d..92cd83ed1 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -37,6 +37,7 @@ from eventlet import event from nova import context from nova import db +from nova import exception from nova import flags from nova import log as logging from nova import utils @@ -228,7 +229,7 @@ class VMWareAPISession(object): except Exception, excep: LOG.critical(_("In vmwareapi:_create_session, " "got this exception: %s") % excep) - raise Exception(excep) + raise exception.Error(excep) def __del__(self): """Logs-out the session.""" -- cgit From 36b5f7d9cf377ce2a4dcdad07e7e14062cd3ec4d Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 11:22:23 -0600 Subject: Further vmops cleanup --- nova/virt/xenapi/vmops.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 5375df5b4..f012fa446 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -536,10 +536,10 @@ class VMOps(object): """ instance_id = instance.id LOG.info(_("Destroying VM for Instance %(instance_id)s") % locals()) - vm = VMHelper.lookup(self._session, instance.name) - return self._destroy(instance, vm, shutdown=True) + vm_ref = VMHelper.lookup(self._session, instance.name) + return self._destroy(instance, vm_ref, shutdown=True) - def _destroy(self, instance, vm, shutdown=True, + def _destroy(self, instance, vm_ref, shutdown=True, destroy_kernel_ramdisk=True): """ Destroys VM instance by performing: @@ -549,17 +549,17 @@ class VMOps(object): 3. Destroying kernel and ramdisk files (if necessary) 4. Destroying that actual VM record """ - if vm is None: + if vm_ref is None: LOG.warning(_("VM is not present, skipping destroy...")) return if shutdown: - self._shutdown(instance, vm) + self._shutdown(instance, vm_ref) - self._destroy_vdis(instance, vm) + self._destroy_vdis(instance, vm_ref) if destroy_kernel_ramdisk: - self._destroy_kernel_ramdisk(instance, vm) - self._destroy_vm(instance, vm) + self._destroy_kernel_ramdisk(instance, vm_ref) + self._destroy_vm(instance, vm_ref) def _wait_with_callback(self, instance_id, task, callback): ret = None -- cgit From e891e48b63065a7218627289a908aece0f6a3730 Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Fri, 11 Mar 2011 10:31:08 -0800 Subject: Made changes to xs-ipv6 code impacted because of addition of flatmanger ipv6 support --- nova/virt/xenapi/vmops.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 9ac83efb0..52d2652f9 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -617,9 +617,10 @@ class VMOps(object): def ip6_dict(ip6): return { - "ip": ip6.addressV6, - "netmask": ip6.netmaskV6, - "gateway": ip6.gatewayV6, + "ip": utils.to_global_ipv6(network['cidr_v6'], + instance['mac_address']), + "netmask": network['netmask_v6'], + "gateway": network['gateway_v6'], "enabled": "1"} mac_id = instance.mac_address.replace(':', '') -- cgit From 0a130010c26e4ef9ba5b9917ff47766de7805ab9 Mon Sep 17 00:00:00 2001 From: Eric Windisch Date: Fri, 11 Mar 2011 14:24:03 -0500 Subject: process_input for tee. fixes: 733439 --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 5d499c42c..9abe44cc3 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -189,4 +189,4 @@ def _inject_net_into_fs(net, fs): utils.execute('sudo', 'chown', 'root:root', netdir) utils.execute('sudo', 'chmod', 755, netdir) netfile = os.path.join(netdir, 'interfaces') - utils.execute('sudo', 'tee', netfile, net) + utils.execute('sudo', 'tee', netfile, process_input=net) -- cgit From 2ac7fa75c02c885fc9d4dfacba8318aadbdbfceb Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Fri, 11 Mar 2011 23:34:26 +0100 Subject: Indentation adjustment (cosmetical). --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index d82b33ddd..678331eed 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1243,7 +1243,7 @@ class IptablesFirewallDriver(FirewallDriver): self.iptables.apply() else: LOG.info(_('Attempted to unfilter instance %s which is not ' - 'filtered'), instance['id']) + 'filtered'), instance['id']) def prepare_instance_filter(self, instance): self.instances[instance['id']] = instance -- cgit From a9d71273742f440af5687650dd9cd72d827a6bef Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Fri, 11 Mar 2011 23:36:28 +0100 Subject: Make the fallback value None instead of False --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 678331eed..d2061a0ca 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1238,7 +1238,7 @@ class IptablesFirewallDriver(FirewallDriver): pass def unfilter_instance(self, instance): - if self.instances.pop(instance['id'], False): + if self.instances.pop(instance['id'], None): self.remove_filters_for_instance(instance) self.iptables.apply() else: -- cgit From da76b3d67b2c2e864025c4ba201b63e1dee2ff1f Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 16:58:18 -0600 Subject: Review feedback --- nova/virt/xenapi/vm_utils.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index a42cabfe4..866eb5d62 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -101,7 +101,7 @@ class VMHelper(HelperBase): get_instance_type(instance.instance_type) mem = str(long(instance_type['memory_mb']) * 1024 * 1024) vcpus = str(instance_type['vcpus']) - vm_rec = { + rec = { 'actions_after_crash': 'destroy', 'actions_after_reboot': 'restart', 'actions_after_shutdown': 'destroy', @@ -145,21 +145,21 @@ class VMHelper(HelperBase): vm_rec['platform']['nx'] = 'false' if instance.kernel_id: # 1. Kernel explicitly passed in, use that - vm_rec['PV_args'] = 'root=/dev/xvda1' - vm_rec['PV_kernel'] = kernel - vm_rec['PV_ramdisk'] = ramdisk + rec['PV_args'] = 'root=/dev/xvda1' + rec['PV_kernel'] = kernel + rec['PV_ramdisk'] = ramdisk else: # 2. Use kernel within the image - vm_rec['PV_args'] = 'clocksource=jiffies' - vm_rec['PV_bootloader'] = 'pygrub' + rec['PV_args'] = 'clocksource=jiffies' + rec['PV_bootloader'] = 'pygrub' else: # 3. Using hardware virtualization - vm_rec['platform']['nx'] = 'true' - vm_rec['HVM_boot_params'] = {'order': 'dc'} - vm_rec['HVM_boot_policy'] = 'BIOS order' + rec['platform']['nx'] = 'true' + rec['HVM_boot_params'] = {'order': 'dc'} + rec['HVM_boot_policy'] = 'BIOS order' LOG.debug(_('Created VM %s...'), instance.name) - vm_ref = session.call_xenapi('VM.create', vm_rec) + vm_ref = session.call_xenapi('VM.create', rec) instance_name = instance.name LOG.debug(_('Created VM %(instance_name)s as %(vm_ref)s.') % locals()) return vm_ref -- cgit From 80bc32659e41f496bb1bfefbdd6ca63de7ff9f98 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 17:11:25 -0600 Subject: Review feedback --- nova/virt/xenapi/vmops.py | 61 +++++++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 28 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 190c2022d..3ccdf9d80 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -434,7 +434,7 @@ class VMOps(object): raise RuntimeError(resp_dict['message']) return resp_dict['message'] - def _shutdown(self, instance, vm, hard=True): + def _shutdown(self, instance, vm_ref, hard=True): """Shutdown an instance""" state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: @@ -448,31 +448,33 @@ class VMOps(object): try: task = None if hard: - task = self._session.call_xenapi("Async.VM.hard_shutdown", vm) + task = self._session.call_xenapi("Async.VM.hard_shutdown", + vm_ref) else: - task = self._session.call_xenapi('Async.VM.clean_shutdown', vm) + task = self._session.call_xenapi("Async.VM.clean_shutdown", + vm_ref) self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure, exc: LOG.exception(exc) - def _destroy_vdis(self, instance, vm): - """Destroys all VDIs associated with a VM """ + def _destroy_vdis(self, instance, vm_ref): + """Destroys all VDIs associated with a VM""" instance_id = instance.id LOG.debug(_("Destroying VDIs for Instance %(instance_id)s") % locals()) - vdis = VMHelper.lookup_vm_vdis(self._session, vm) + vdi_refs = VMHelper.lookup_vm_vdis(self._session, vm_ref) - if not vdis: + if not vdi_refs: return - for vdi in vdis: + for vdi_ref in vdi_refs: try: - task = self._session.call_xenapi('Async.VDI.destroy', vdi) + task = self._session.call_xenapi('Async.VDI.destroy', vdi_ref) self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure, exc: LOG.exception(exc) - def _destroy_kernel_ramdisk(self, instance, vm): + def _destroy_kernel_ramdisk(self, instance, vm_ref): """ Three situations can occur: @@ -499,8 +501,8 @@ class VMOps(object): "both" % locals())) # 3. We have both kernel and ramdisk - (kernel, ramdisk) = VMHelper.lookup_kernel_ramdisk( - self._session, vm) + (kernel, ramdisk) = VMHelper.lookup_kernel_ramdisk(self._session, + vm_ref) LOG.debug(_("Removing kernel/ramdisk files")) @@ -511,11 +513,11 @@ class VMOps(object): LOG.debug(_("kernel/ramdisk files removed")) - def _destroy_vm(self, instance, vm): - """Destroys a VM record """ + def _destroy_vm(self, instance, vm_ref): + """Destroys a VM record""" instance_id = instance.id try: - task = self._session.call_xenapi('Async.VM.destroy', vm) + task = self._session.call_xenapi('Async.VM.destroy', vm_ref) self._session.wait_for_task(task, instance_id) except self.XenAPI.Failure, exc: LOG.exception(exc) @@ -596,8 +598,9 @@ class VMOps(object): - spawn a rescue VM (the vm name-label will be instance-N-rescue) """ - rescue_vm = VMHelper.lookup(self._session, instance.name + "-rescue") - if rescue_vm: + rescue_vm_ref = VMHelper.lookup(self._session, + instance.name + "-rescue") + if rescue_vm_ref: raise RuntimeError(_( "Instance is already in Rescue Mode: %s" % instance.name)) @@ -609,8 +612,8 @@ class VMOps(object): self.spawn(instance) rescue_vm_ref = self._get_vm_opaque_ref(instance) - vbd = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0] - vdi_ref = self._session.get_xenapi().VBD.get_record(vbd)["VDI"] + vbd_ref = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0] + vdi_ref = self._session.get_xenapi().VBD.get_record(vbd_ref)["VDI"] vbd_ref = VMHelper.create_vbd(self._session, rescue_vm_ref, vdi_ref, 1, False) @@ -623,35 +626,37 @@ class VMOps(object): - release the bootlock to allow the instance VM to start """ - rescue_vm = VMHelper.lookup(self._session, instance.name + "-rescue") + rescue_vm_ref = VMHelper.lookup(self._session, + instance.name + "-rescue") - if not rescue_vm: + if not rescue_vm_ref: raise exception.NotFound(_( "Instance is not in Rescue Mode: %s" % instance.name)) original_vm_ref = self._get_vm_opaque_ref(instance) - vbds = self._session.get_xenapi().VM.get_VBDs(rescue_vm) + vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref) instance._rescue = False - for vbd_ref in vbds: + for vbd_ref in vbd_refs: vbd = self._session.get_xenapi().VBD.get_record(vbd_ref) if vbd["userdevice"] == "1": VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) - task1 = self._session.call_xenapi("Async.VM.hard_shutdown", rescue_vm) + task1 = self._session.call_xenapi("Async.VM.hard_shutdown", + rescue_vm_ref) self._session.wait_for_task(task1, instance.id) - vdis = VMHelper.lookup_vm_vdis(self._session, rescue_vm) - for vdi in vdis: + vdi_refs = VMHelper.lookup_vm_vdis(self._session, rescue_vm_ref) + for vdi_ref in vdi_refs: try: - task = self._session.call_xenapi('Async.VDI.destroy', vdi) + task = self._session.call_xenapi('Async.VDI.destroy', vdi_ref) self._session.wait_for_task(task, instance.id) except self.XenAPI.Failure: continue - task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm) + task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm_ref) self._session.wait_for_task(task2, instance.id) self._release_bootlock(original_vm_ref) -- cgit From ab37248cc2e40b06e1d349833da01494a9ca3641 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 17:13:10 -0600 Subject: oops --- nova/virt/xenapi/vm_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 866eb5d62..8dd246178 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -142,7 +142,7 @@ class VMHelper(HelperBase): # Complete VM configuration record according to the image type # non-raw/raw with PV kernel/raw in HVM mode if use_pv_kernel: - vm_rec['platform']['nx'] = 'false' + rec['platform']['nx'] = 'false' if instance.kernel_id: # 1. Kernel explicitly passed in, use that rec['PV_args'] = 'root=/dev/xvda1' -- cgit From f9706b5080786a4d3e530f3e8bdb69147e9f5086 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 17:35:37 -0600 Subject: Review feedback --- nova/virt/xenapi/vm_utils.py | 31 ++++++++++++++++--------------- nova/virt/xenapi/vmops.py | 6 +++--- 2 files changed, 19 insertions(+), 18 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 8dd246178..7aa3f3c3b 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -633,37 +633,38 @@ class VMHelper(HelperBase): return is_pv @classmethod - def lookup(cls, session, i): + def lookup(cls, session, name_label): """Look the instance i up, and returns it if available""" - vms = session.get_xenapi().VM.get_by_name_label(i) - n = len(vms) + vm_refs = session.get_xenapi().VM.get_by_name_label(name_label) + n = len(vm_refs) if n == 0: return None elif n > 1: - raise exception.Duplicate(_('duplicate name found: %s') % i) + raise exception.Duplicate(_('duplicate name found: %s') % + name_label) else: - return vms[0] + return vm_refs[0] @classmethod - def lookup_vm_vdis(cls, session, vm): + def lookup_vm_vdis(cls, session, vm_ref): """Look for the VDIs that are attached to the VM""" # Firstly we get the VBDs, then the VDIs. # TODO(Armando): do we leave the read-only devices? - vbds = session.get_xenapi().VM.get_VBDs(vm) - vdis = [] - if vbds: - for vbd in vbds: + vbd_refs = session.get_xenapi().VM.get_VBDs(vm_ref) + vdi_refs = [] + if vbd_refs: + for vbd_ref in vbd_refs: try: - vdi = session.get_xenapi().VBD.get_VDI(vbd) + vdi_ref = session.get_xenapi().VBD.get_VDI(vbd_ref) # Test valid VDI - record = session.get_xenapi().VDI.get_record(vdi) + record = session.get_xenapi().VDI.get_record(vdi_ref) LOG.debug(_('VDI %s is still available'), record['uuid']) except cls.XenAPI.Failure, exc: LOG.exception(exc) else: - vdis.append(vdi) - if len(vdis) > 0: - return vdis + vdi_refs.append(vdi_ref) + if len(vdi_refs) > 0: + return vdi_refs else: return None diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3ccdf9d80..0faec1169 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -614,10 +614,10 @@ class VMOps(object): vbd_ref = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0] vdi_ref = self._session.get_xenapi().VBD.get_record(vbd_ref)["VDI"] - vbd_ref = VMHelper.create_vbd(self._session, rescue_vm_ref, vdi_ref, - 1, False) + rescue_vbd_ref = VMHelper.create_vbd(self._session, rescue_vm_ref, + vdi_ref, 1, False) - self._session.call_xenapi("Async.VBD.plug", vbd_ref) + self._session.call_xenapi("Async.VBD.plug", rescue_vbd_ref) def unrescue(self, instance, callback): """Unrescue the specified instance -- cgit From cdd8790426d3eb77712f5a19f99211b12a9ad9c5 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 17:48:44 -0600 Subject: Review feedback --- nova/virt/xenapi/vm_utils.py | 10 +++++----- nova/virt/xenapi/vmops.py | 6 +++--- nova/virt/xenapi/volume_utils.py | 6 +++--- 3 files changed, 11 insertions(+), 11 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 7aa3f3c3b..1a872345d 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -202,13 +202,13 @@ class VMHelper(HelperBase): @classmethod def find_vbd_by_number(cls, session, vm_ref, number): """Get the VBD reference from the device number""" - vbds = session.get_xenapi().VM.get_VBDs(vm_ref) - if vbds: - for vbd in vbds: + vbd_refs = session.get_xenapi().VM.get_VBDs(vm_ref) + if vbd_refs: + for vbd_ref in vbd_refs: try: - vbd_rec = session.get_xenapi().VBD.get_record(vbd) + vbd_rec = session.get_xenapi().VBD.get_record(vbd_ref) if vbd_rec['userdevice'] == str(number): - return vbd + return vbd_ref except cls.XenAPI.Failure, exc: LOG.exception(exc) raise StorageError(_('VBD not found in instance %s') % vm_ref) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 0faec1169..382915b0c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -55,12 +55,12 @@ class VMOps(object): def list_instances(self): """List VM instances""" - vms = [] + vm_refs = [] for vm_ref in self._session.get_xenapi().VM.get_all(): vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) if not vm_rec["is_a_template"] and not vm_rec["is_control_domain"]: - vms.append(vm_rec["name_label"]) - return vms + vm_refs.append(vm_rec["name_label"]) + return vm_refs def _start(self, instance, vm_ref=None): """Power on a VM instance""" diff --git a/nova/virt/xenapi/volume_utils.py b/nova/virt/xenapi/volume_utils.py index d5ebd29d5..72284ac02 100644 --- a/nova/virt/xenapi/volume_utils.py +++ b/nova/virt/xenapi/volume_utils.py @@ -117,16 +117,16 @@ class VolumeHelper(HelperBase): def introduce_vdi(cls, session, sr_ref): """Introduce VDI in the host""" try: - vdis = session.get_xenapi().SR.get_VDIs(sr_ref) + vdi_refs = session.get_xenapi().SR.get_VDIs(sr_ref) except cls.XenAPI.Failure, exc: LOG.exception(exc) raise StorageError(_('Unable to introduce VDI on SR %s') % sr_ref) try: - vdi_rec = session.get_xenapi().VDI.get_record(vdis[0]) + vdi_rec = session.get_xenapi().VDI.get_record(vdi_refs[0]) except cls.XenAPI.Failure, exc: LOG.exception(exc) raise StorageError(_('Unable to get record' - ' of VDI %s on') % vdis[0]) + ' of VDI %s on') % vdi_refs[0]) else: try: return session.get_xenapi().VDI.introduce( -- cgit From 48196abaf7e9c47bfda3f744e0be9bc242004b72 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 18:00:34 -0600 Subject: Review feedback --- nova/virt/xenapi/vm_utils.py | 56 ++++++++++++++++++++++---------------------- nova/virt/xenapi/vmops.py | 8 +++---- 2 files changed, 32 insertions(+), 32 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 1a872345d..4d55937e3 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -443,29 +443,29 @@ class VMHelper(HelperBase): vdi_size += MBR_SIZE_BYTES name_label = get_name_label_for_image(image) - vdi = cls.create_vdi(session, sr_ref, name_label, vdi_size, False) + vdi_ref = cls.create_vdi(session, sr_ref, name_label, vdi_size, False) - with_vdi_attached_here(session, vdi, False, + with_vdi_attached_here(session, vdi_ref, False, lambda dev: _stream_disk(dev, image_type, virtual_size, image_file)) if image_type == ImageType.KERNEL_RAMDISK: #we need to invoke a plugin for copying VDI's #content into proper path - LOG.debug(_("Copying VDI %s to /boot/guest on dom0"), vdi) + LOG.debug(_("Copying VDI %s to /boot/guest on dom0"), vdi_ref) fn = "copy_kernel_vdi" args = {} - args['vdi-ref'] = vdi + args['vdi-ref'] = vdi_ref #let the plugin copy the correct number of bytes args['image-size'] = str(vdi_size) task = session.async_call_plugin('glance', fn, args) filename = session.wait_for_task(task, instance_id) #remove the VDI as it is not needed anymore - session.get_xenapi().VDI.destroy(vdi) - LOG.debug(_("Kernel/Ramdisk VDI %s destroyed"), vdi) + session.get_xenapi().VDI.destroy(vdi_ref) + LOG.debug(_("Kernel/Ramdisk VDI %s destroyed"), vdi_ref) return filename else: - return session.get_xenapi().VDI.get_uuid(vdi) + return session.get_xenapi().VDI.get_uuid(vdi_ref) @classmethod def determine_disk_image_type(cls, instance): @@ -840,16 +840,16 @@ def safe_find_sr(session): def find_sr(session): """Return the storage repository to hold VM images""" host = session.get_xenapi_host() - srs = session.get_xenapi().SR.get_all() - for sr in srs: - sr_rec = session.get_xenapi().SR.get_record(sr) + sr_refs = session.get_xenapi().SR.get_all() + for sr_ref in sr_refs: + sr_rec = session.get_xenapi().SR.get_record(sr_ref) if not ('i18n-key' in sr_rec['other_config'] and sr_rec['other_config']['i18n-key'] == 'local-storage'): continue - for pbd in sr_rec['PBDs']: - pbd_rec = session.get_xenapi().PBD.get_record(pbd) + for pbd_ref in sr_rec['PBDs']: + pbd_rec = session.get_xenapi().PBD.get_record(pbd_ref) if pbd_rec['host'] == host: - return sr + return sr_ref return None @@ -874,11 +874,11 @@ def remap_vbd_dev(dev): return remapped_dev -def with_vdi_attached_here(session, vdi, read_only, f): +def with_vdi_attached_here(session, vdi_ref, read_only, f): this_vm_ref = get_this_vm_ref(session) vbd_rec = {} vbd_rec['VM'] = this_vm_ref - vbd_rec['VDI'] = vdi + vbd_rec['VDI'] = vdi_ref vbd_rec['userdevice'] = 'autodetect' vbd_rec['bootable'] = False vbd_rec['mode'] = read_only and 'RO' or 'RW' @@ -889,14 +889,14 @@ def with_vdi_attached_here(session, vdi, read_only, f): vbd_rec['qos_algorithm_type'] = '' vbd_rec['qos_algorithm_params'] = {} vbd_rec['qos_supported_algorithms'] = [] - LOG.debug(_('Creating VBD for VDI %s ... '), vdi) - vbd = session.get_xenapi().VBD.create(vbd_rec) - LOG.debug(_('Creating VBD for VDI %s done.'), vdi) + LOG.debug(_('Creating VBD for VDI %s ... '), vdi_ref) + vbd_ref = session.get_xenapi().VBD.create(vbd_rec) + LOG.debug(_('Creating VBD for VDI %s done.'), vdi_ref) try: - LOG.debug(_('Plugging VBD %s ... '), vbd) - session.get_xenapi().VBD.plug(vbd) - LOG.debug(_('Plugging VBD %s done.'), vbd) - orig_dev = session.get_xenapi().VBD.get_device(vbd) + LOG.debug(_('Plugging VBD %s ... '), vbd_ref) + session.get_xenapi().VBD.plug(vbd_ref) + LOG.debug(_('Plugging VBD %s done.'), vbd_ref) + orig_dev = session.get_xenapi().VBD.get_device(vbd_ref) LOG.debug(_('VBD %(vbd)s plugged as %(orig_dev)s') % locals()) dev = remap_vbd_dev(orig_dev) if dev != orig_dev: @@ -904,13 +904,13 @@ def with_vdi_attached_here(session, vdi, read_only, f): 'remapping to %(dev)s') % locals()) return f(dev) finally: - LOG.debug(_('Destroying VBD for VDI %s ... '), vdi) - vbd_unplug_with_retry(session, vbd) - ignore_failure(session.get_xenapi().VBD.destroy, vbd) - LOG.debug(_('Destroying VBD for VDI %s done.'), vdi) + LOG.debug(_('Destroying VBD for VDI %s ... '), vdi_ref) + vbd_unplug_with_retry(session, vbd_ref) + ignore_failure(session.get_xenapi().VBD.destroy, vbd_ref) + LOG.debug(_('Destroying VBD for VDI %s done.'), vdi_ref) -def vbd_unplug_with_retry(session, vbd): +def vbd_unplug_with_retry(session, vbd_ref): """Call VBD.unplug on the given VBD, with a retry if we get DEVICE_DETACH_REJECTED. For reasons which I don't understand, we're seeing the device still in use, even when all processes using the device @@ -918,7 +918,7 @@ def vbd_unplug_with_retry(session, vbd): # FIXME(sirp): We can use LoopingCall here w/o blocking sleep() while True: try: - session.get_xenapi().VBD.unplug(vbd) + session.get_xenapi().VBD.unplug(vbd_ref) LOG.debug(_('VBD.unplug successful first time.')) return except VMHelper.XenAPI.Failure, e: diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 382915b0c..fcb290d03 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -87,8 +87,8 @@ class VMOps(object): def _spawn_with_disk(self, instance, vdi_uuid): """Create VM instance""" instance_name = instance.name - vm = VMHelper.lookup(self._session, instance_name) - if vm is not None: + vm_ref = VMHelper.lookup(self._session, instance_name) + if vm_ref is not None: raise exception.Duplicate(_('Attempted to create' ' non-unique name %s') % instance_name) @@ -639,8 +639,8 @@ class VMOps(object): instance._rescue = False for vbd_ref in vbd_refs: - vbd = self._session.get_xenapi().VBD.get_record(vbd_ref) - if vbd["userdevice"] == "1": + _vbd_ref = self._session.get_xenapi().VBD.get_record(vbd_ref) + if _vbd_ref["userdevice"] == "1": VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) -- cgit From b944cbcbf023ca321edcc511354b56aa5b07d438 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Fri, 11 Mar 2011 18:03:19 -0600 Subject: oops --- nova/virt/xenapi/vm_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 4d55937e3..f07b57796 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -897,10 +897,10 @@ def with_vdi_attached_here(session, vdi_ref, read_only, f): session.get_xenapi().VBD.plug(vbd_ref) LOG.debug(_('Plugging VBD %s done.'), vbd_ref) orig_dev = session.get_xenapi().VBD.get_device(vbd_ref) - LOG.debug(_('VBD %(vbd)s plugged as %(orig_dev)s') % locals()) + LOG.debug(_('VBD %(vbd_ref)s plugged as %(orig_dev)s') % locals()) dev = remap_vbd_dev(orig_dev) if dev != orig_dev: - LOG.debug(_('VBD %(vbd)s plugged into wrong dev, ' + LOG.debug(_('VBD %(vbd_ref)s plugged into wrong dev, ' 'remapping to %(dev)s') % locals()) return f(dev) finally: -- cgit From ce57cff740bc7f821bdbb0dd1367c037b6fa1c01 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 14 Mar 2011 14:02:27 -0700 Subject: The exception is called "ApiError", not "APIError" --- nova/virt/libvirt_conn.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0b306c950..7994e9547 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -362,19 +362,19 @@ class LibvirtConnection(object): @exception.wrap_exception def pause(self, instance, callback): - raise exception.APIError("pause not supported for libvirt.") + raise exception.ApiError("pause not supported for libvirt.") @exception.wrap_exception def unpause(self, instance, callback): - raise exception.APIError("unpause not supported for libvirt.") + raise exception.ApiError("unpause not supported for libvirt.") @exception.wrap_exception def suspend(self, instance, callback): - raise exception.APIError("suspend not supported for libvirt") + raise exception.ApiError("suspend not supported for libvirt") @exception.wrap_exception def resume(self, instance, callback): - raise exception.APIError("resume not supported for libvirt") + raise exception.ApiError("resume not supported for libvirt") @exception.wrap_exception def rescue(self, instance, callback=None): @@ -779,7 +779,7 @@ class LibvirtConnection(object): 'cpu_time': cpu_time} def get_diagnostics(self, instance_name): - raise exception.APIError(_("diagnostics are not supported " + raise exception.ApiError(_("diagnostics are not supported " "for libvirt")) def get_disks(self, instance_name): -- cgit From 337bda95a9e12d395f838e81e279c875b056aba9 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Mon, 14 Mar 2011 22:17:14 +0100 Subject: Add missing fallback chain for ipv6. --- nova/virt/libvirt_conn.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0b306c950..03f046cbd 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1597,6 +1597,9 @@ class IptablesFirewallDriver(FirewallDriver): self.iptables.ipv4['filter'].add_chain('sg-fallback') self.iptables.ipv4['filter'].add_rule('sg-fallback', '-j DROP') + if FLAGS.use_ipv6: + self.iptables.ipv6['filter'].add_chain('sg-fallback') + self.iptables.ipv6['filter'].add_rule('sg-fallback', '-j DROP') def setup_basic_filtering(self, instance): """Use NWFilter from libvirt for this.""" -- cgit From c94ec9a5bab6c07b402b68e2f4ff081247a27cda Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 14 Mar 2011 14:17:58 -0700 Subject: Initial implementation of refresh instance states --- nova/virt/connection.py | 4 +++- nova/virt/fake.py | 36 ++++++++++++++++++++++++++---------- nova/virt/hyperv.py | 4 +++- nova/virt/libvirt_conn.py | 24 +++++++++++++++++++++++- nova/virt/xenapi/vmops.py | 19 +++++++++++++++++++ nova/virt/xenapi_conn.py | 7 ++++++- 6 files changed, 80 insertions(+), 14 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/connection.py b/nova/virt/connection.py index 13181b730..d585b6c21 100644 --- a/nova/virt/connection.py +++ b/nova/virt/connection.py @@ -23,6 +23,8 @@ import sys from nova import flags from nova import log as logging +from nova import utils +from nova.compute import driver from nova.virt import fake from nova.virt import libvirt_conn from nova.virt import xenapi_conn @@ -72,4 +74,4 @@ def get_connection(read_only=False): if conn is None: LOG.error(_('Failed to open connection to the hypervisor')) sys.exit(1) - return conn + return utils.check_instance(conn, driver.ComputeDriver) diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 3a06284a1..18cca3f5e 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -26,6 +26,8 @@ semantics of real hypervisor connections. """ from nova import exception +from nova import utils +from nova.compute import driver from nova.compute import power_state @@ -34,7 +36,14 @@ def get_connection(_): return FakeConnection.instance() -class FakeConnection(object): +class FakeInstance(object): + + def __init__(self, name, state): + self.name = name + self.state = state + + +class FakeConnection(driver.ComputeDriver): """ The interface to this class talks in terms of 'instances' (Amazon EC2 and internal Nova terminology), by which we mean 'running virtual machine' @@ -90,6 +99,17 @@ class FakeConnection(object): """ return self.instances.keys() + def _map_to_instance_info(self, instance): + instance = utils.check_instance(instance, FakeInstance) + info = driver.InstanceInfo(instance.name, instance.state) + return info + + def list_instances_detail(self): + info_list = [] + for instance in self.instances: + info_list.append(self._map_to_instance_info(instance)) + return info_list + def spawn(self, instance): """ Create a new instance/VM/domain on the virtualization platform. @@ -109,9 +129,10 @@ class FakeConnection(object): that it was before this call began. """ - fake_instance = FakeInstance() - self.instances[instance.name] = fake_instance - fake_instance._state = power_state.RUNNING + name = instance.name + state = power_state.RUNNING + fake_instance = FakeInstance(name, state) + self.instances[name] = fake_instance def snapshot(self, instance, name): """ @@ -270,7 +291,7 @@ class FakeConnection(object): raise exception.NotFound(_("Instance %s Not Found") % instance_name) i = self.instances[instance_name] - return {'state': i._state, + return {'state': i.state, 'max_mem': 0, 'mem': 0, 'num_cpu': 2, @@ -428,8 +449,3 @@ class FakeConnection(object): """This method is supported only by libvirt.""" raise NotImplementedError('This method is supported only by libvirt.') - -class FakeInstance(object): - - def __init__(self): - self._state = power_state.NOSTATE diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py index 29d18dac5..aea7413c6 100644 --- a/nova/virt/hyperv.py +++ b/nova/virt/hyperv.py @@ -67,6 +67,7 @@ from nova import exception from nova import flags from nova import log as logging from nova.auth import manager +from nova.compute import driver from nova.compute import power_state from nova.virt import images @@ -108,8 +109,9 @@ def get_connection(_): return HyperVConnection() -class HyperVConnection(object): +class HyperVConnection(driver.ComputeDriver): def __init__(self): + super(HyperVConnection, self).__init__() self._conn = wmi.WMI(moniker='//./root/virtualization') self._cim_conn = wmi.WMI(moniker='//./root/cimv2') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0b306c950..e95bcac39 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -60,6 +60,7 @@ from nova import log as logging #from nova import test from nova import utils from nova.auth import manager +from nova.compute import driver from nova.compute import instance_types from nova.compute import power_state from nova.virt import disk @@ -154,9 +155,10 @@ def _get_ip_version(cidr): return int(net.version()) -class LibvirtConnection(object): +class LibvirtConnection(driver.ComputeDriver): def __init__(self, read_only): + super(LibvirtConnection, self).__init__() self.libvirt_uri = self.get_uri() self.libvirt_xml = open(FLAGS.libvirt_xml_template).read() @@ -235,6 +237,26 @@ class LibvirtConnection(object): return [self._conn.lookupByID(x).name() for x in self._conn.listDomainsID()] + def _map_to_instance_info(self, domain): + # .info() returns a list of: + #state: one of the state values (virDomainState) + #maxMemory: the maximum memory used by the domain + #memory: the current amount of memory used by the domain + #nbVirtCPU: the number of virtual CPU + #cpuTime: the time used by the domain in nanoseconds + (state, _max_mem, _mem, _num_cpu, _cpu_time) = domain.info() + name = domain.name() + + return driver.InstanceInfo(name, state) + + def list_instances_detail(self): + infos = [] + for domain_id in self._conn.listDomainsID(): + domain = self._conn.lookupById(domain_id) + info = self._map_to_instance_info(domain) + infos.append(info) + return infos + def destroy(self, instance, cleanup=True): try: virt_dom = self._conn.lookupByName(instance['name']) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index fcb290d03..2fce93e38 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -34,6 +34,7 @@ from nova import exception from nova import utils from nova.auth.manager import AuthManager +from nova.compute import driver from nova.compute import power_state from nova.virt.xenapi.network_utils import NetworkHelper from nova.virt.xenapi.vm_utils import VMHelper @@ -55,6 +56,8 @@ class VMOps(object): def list_instances(self): """List VM instances""" + # TODO(justinsb): Should we just always use the details method? + # Seems to be the same number of API calls.. vm_refs = [] for vm_ref in self._session.get_xenapi().VM.get_all(): vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) @@ -62,6 +65,22 @@ class VMOps(object): vm_refs.append(vm_rec["name_label"]) return vm_refs + def list_instances_detail(self): + """List VM instances, returning InstanceInfo objects""" + instance_infos = [] + for vm_ref in self._session.get_xenapi().VM.get_all(): + vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) + if not vm_rec["is_a_template"] and not vm_rec["is_control_domain"]: + name = vm_rec["name_label"] + + #TODO(justinsb): Yuk... + openstack_format = VMHelper.compile_info(vm_rec) + state = openstack_format['state'] + + instance_info = driver.InstanceInfo(name, state) + instance_infos.append(instance_info) + return instance_infos + def _start(self, instance, vm_ref=None): """Power on a VM instance""" if not vm_ref: diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index da42a83b6..9390db0bb 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -69,6 +69,7 @@ from nova import db from nova import utils from nova import flags from nova import log as logging +from nova.compute import driver from nova.virt.xenapi.vmops import VMOps from nova.virt.xenapi.volumeops import VolumeOps @@ -141,10 +142,11 @@ def get_connection(_): return XenAPIConnection(url, username, password) -class XenAPIConnection(object): +class XenAPIConnection(driver.ComputeDriver): """A connection to XenServer or Xen Cloud Platform""" def __init__(self, url, user, pw): + super(XenAPIConnection, self).__init__() session = XenAPISession(url, user, pw) self._vmops = VMOps(session) self._volumeops = VolumeOps(session) @@ -160,6 +162,9 @@ class XenAPIConnection(object): """List VM instances""" return self._vmops.list_instances() + def list_instances_detail(self): + return self._vmops.list_instances_detail() + def spawn(self, instance): """Create VM instance""" self._vmops.spawn(instance) -- cgit From 408a2591d60f5d238e60e4be9197ccc7262f2406 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 14 Mar 2011 16:21:33 -0500 Subject: PEP8 cleanup --- nova/virt/xenapi/vm_utils.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index f07b57796..763c5fe40 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -136,8 +136,7 @@ class VMHelper(HelperBase): 'VCPUs_at_startup': vcpus, 'VCPUs_max': vcpus, 'VCPUs_params': {}, - 'xenstore_data': {} - } + 'xenstore_data': {}} # Complete VM configuration record according to the image type # non-raw/raw with PV kernel/raw in HVM mode -- cgit From 5a0d4fbc24e897e4aa861819fd2f861e7dedcb6b Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 14 Mar 2011 16:33:01 -0500 Subject: added structure to virt.xenapi.vmops to support network info being passed in --- nova/virt/xenapi/vmops.py | 109 ++++++++++++++++++++++++++-------------------- 1 file changed, 62 insertions(+), 47 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index fcb290d03..bec403543 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -80,11 +80,11 @@ class VMOps(object): instance.image_id, user, project, disk_image_type) return vdi_uuid - def spawn(self, instance): + def spawn(self, instance, network_info=None): vdi_uuid = self.create_disk(instance) - self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) + self._spawn_with_disk(instance, vdi_uuid=vdi_uuid, network_info) - def _spawn_with_disk(self, instance, vdi_uuid): + def _spawn_with_disk(self, instance, vdi_uuid, network_info=None): """Create VM instance""" instance_name = instance.name vm_ref = VMHelper.lookup(self._session, instance_name) @@ -128,8 +128,13 @@ class VMOps(object): vdi_ref=vdi_ref, userdevice=0, bootable=True) # inject_network_info and create vifs - networks = self.inject_network_info(instance) - self.create_vifs(instance, networks) + if network_info is not None: + self.inject_network_info(instance, network_info) + self.create_vifs(instance, [nw for (nw, mapping) in network_info]) + else: + # TODO(tr3buchet) - goes away with multi-nic + networks = self.inject_network_info(instance) + self.create_vifs(instance, networks) LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) @@ -684,59 +689,68 @@ class VMOps(object): # TODO: implement this! return 'http://fakeajaxconsole/fake_url' - def inject_network_info(self, instance): + def inject_network_info(self, instance, network_info=None): """ Generate the network info and make calls to place it into the xenstore and the xenstore param list """ - # TODO(tr3buchet) - remove comment in multi-nic - # I've decided to go ahead and consider multiple IPs and networks - # at this stage even though they aren't implemented because these will - # be needed for multi-nic and there was no sense writing it for single - # network/single IP and then having to turn around and re-write it vm_ref = self._get_vm_opaque_ref(instance.id) logging.debug(_("injecting network info to xenstore for vm: |%s|"), vm_ref) - admin_context = context.get_admin_context() - IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) - networks = db.network_get_all_by_instance(admin_context, + if network_info is not None: + for (network, mapping) in network_info: + self.write_to_param_xenstore(vm_ref, {location: mapping}) + try: + self.write_to_xenstore(vm_ref, location, + mapping['location']) + except KeyError: + # catch KeyError for domid if instance isn't running + pass + else: + # TODO(tr3buchet) - this bit here when network_info is None goes + # away with multi-nic + admin_context = context.get_admin_context() + IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) - for network in networks: - network_IPs = [ip for ip in IPs if ip.network_id == network.id] - - def ip_dict(ip): - return { - "ip": ip.address, - "netmask": network["netmask"], - "enabled": "1"} - - def ip6_dict(ip6): - return { - "ip": ip6.addressV6, - "netmask": ip6.netmaskV6, - "gateway": ip6.gatewayV6, - "enabled": "1"} - - mac_id = instance.mac_address.replace(':', '') - location = 'vm-data/networking/%s' % mac_id - mapping = { - 'label': network['label'], - 'gateway': network['gateway'], - 'mac': instance.mac_address, - 'dns': [network['dns']], - 'ips': [ip_dict(ip) for ip in network_IPs], - 'ip6s': [ip6_dict(ip) for ip in network_IPs]} - - self.write_to_param_xenstore(vm_ref, {location: mapping}) + networks = db.network_get_all_by_instance(admin_context, + instance['id']) + for network in networks: + network_IPs = [ip for ip in IPs if ip.network_id == network.id] + + def ip_dict(ip): + return { + "ip": ip.address, + "netmask": network["netmask"], + "enabled": "1"} + + def ip6_dict(ip6): + return { + "ip": ip6.addressV6, + "netmask": ip6.netmaskV6, + "gateway": ip6.gatewayV6, + "enabled": "1"} + + mac_id = instance.mac_address.replace(':', '') + location = 'vm-data/networking/%s' % mac_id + mapping = { + 'label': network['label'], + 'gateway': network['gateway'], + 'mac': instance.mac_address, + 'dns': [network['dns']], + 'ips': [ip_dict(ip) for ip in network_IPs], + 'ip6s': [ip6_dict(ip) for ip in network_IPs]} + + self.write_to_param_xenstore(vm_ref, {location: mapping}) - try: - self.write_to_xenstore(vm_ref, location, mapping['location']) - except KeyError: - # catch KeyError for domid if instance isn't running - pass + try: + self.write_to_xenstore(vm_ref, location, + mapping['location']) + except KeyError: + # catch KeyError for domid if instance isn't running + pass - return networks + return networks def create_vifs(self, instance, networks=None): """ @@ -745,6 +759,7 @@ class VMOps(object): """ vm_ref = self._get_vm_opaque_ref(instance.id) logging.debug(_("creating vif(s) for vm: |%s|"), vm_ref) + # TODO(tr3buchet) - goes away with multi-nic if networks is None: networks = db.network_get_all_by_instance(admin_context, instance['id']) -- cgit From 54f16ee6012082c1ad9de423698573c5d9b47540 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 14 Mar 2011 14:38:39 -0700 Subject: pep8 --- nova/virt/fake.py | 1 - nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 18cca3f5e..ccf2a7d68 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -448,4 +448,3 @@ class FakeConnection(driver.ComputeDriver): def unfilter_instance(self, instance_ref): """This method is supported only by libvirt.""" raise NotImplementedError('This method is supported only by libvirt.') - diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 2fce93e38..3a58a887e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -72,7 +72,7 @@ class VMOps(object): vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) if not vm_rec["is_a_template"] and not vm_rec["is_control_domain"]: name = vm_rec["name_label"] - + #TODO(justinsb): Yuk... openstack_format = VMHelper.compile_info(vm_rec) state = openstack_format['state'] -- cgit From 1d1e5e38175ff7956b3a28ccc1ce61f700700e8b Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 14 Mar 2011 16:38:53 -0500 Subject: fixed keyword arg error --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index bec403543..64f2c6231 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -82,7 +82,7 @@ class VMOps(object): def spawn(self, instance, network_info=None): vdi_uuid = self.create_disk(instance) - self._spawn_with_disk(instance, vdi_uuid=vdi_uuid, network_info) + self._spawn_with_disk(instance, vdi_uuid, network_info) def _spawn_with_disk(self, instance, vdi_uuid, network_info=None): """Create VM instance""" -- cgit From 5b1422afe12d4e9b7fdfdc6a61cdcd51962dab4d Mon Sep 17 00:00:00 2001 From: Tushar Patil Date: Mon, 14 Mar 2011 14:43:53 -0700 Subject: Fix for LP Bug #704300 --- nova/virt/libvirt_conn.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0b306c950..e0222956e 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -339,7 +339,11 @@ class LibvirtConnection(object): def reboot(self, instance): self.destroy(instance, False) xml = self.to_xml(instance) + self.firewall_driver.setup_basic_filtering(instance) + self.firewall_driver.prepare_instance_filter(instance) self._conn.createXML(xml, 0) + self.firewall_driver.apply_instance_filter(instance) + timer = utils.LoopingCall(f=None) def _wait_for_reboot(): -- cgit From 738653b6b4ac744519a050fe50e7c795a7c63579 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 14 Mar 2011 15:11:14 -0700 Subject: Added test and fixed up code so that it works --- nova/virt/fake.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index ccf2a7d68..e0e2369c7 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -106,7 +106,7 @@ class FakeConnection(driver.ComputeDriver): def list_instances_detail(self): info_list = [] - for instance in self.instances: + for instance in self.instances.values(): info_list.append(self._map_to_instance_info(instance)) return info_list @@ -448,3 +448,7 @@ class FakeConnection(driver.ComputeDriver): def unfilter_instance(self, instance_ref): """This method is supported only by libvirt.""" raise NotImplementedError('This method is supported only by libvirt.') + + def test_remove_vm(self, instance_name): + """ Removes the named VM, as if it crashed. For testing""" + self.instances.pop(instance_name) -- cgit From 9f135cc4d6069a0b882c8e848d3b6cb292002d10 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 14 Mar 2011 15:37:04 -0700 Subject: Implemented Hyper-V list_instances_detail function. Needs a cleanup by someone that knows the Hyper-V code --- nova/virt/hyperv.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py index aea7413c6..435272109 100644 --- a/nova/virt/hyperv.py +++ b/nova/virt/hyperv.py @@ -126,6 +126,19 @@ class HyperVConnection(driver.ComputeDriver): for v in self._conn.Msvm_ComputerSystem(['ElementName'])] return vms + def list_instances_detail(self): + #TODO(justinsb): This is a terrible implementation (1+N) + instance_infos = [] + for instance_name in self.list_instances(): + info = self.get_info(instance_name) + + state = info['state'] + + instance_info = driver.InstanceInfo(instance_name, state) + instance_infos.append(instance_info) + + return instance_infos + def spawn(self, instance): """ Create a new VM and start it.""" vm = self._lookup(instance.name) @@ -347,7 +360,7 @@ class HyperVConnection(driver.ComputeDriver): newinst = cl.new() #Copy the properties from the original. for prop in wmi_obj._properties: - newinst.Properties_.Item(prop).Value =\ + newinst.Properties_.Item(prop).Value = \ wmi_obj.Properties_.Item(prop).Value return newinst -- cgit From 743e82c0acac0fda78a55a8bbb65e601c4cb652c Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Mon, 14 Mar 2011 21:14:39 -0400 Subject: Refactor setup contianer/destroy container --- nova/virt/disk.py | 33 ++++++++++++++------------------- 1 file changed, 14 insertions(+), 19 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index f0b391efb..a3db1d882 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -122,31 +122,26 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): to create the root filesystem for the container """ device = _link_device(image, nbd) - try: - if not partition is None: - # create partition - utils.execute('sudo kpartx -a %s' % device) - mapped_device = '/dev/mapper/%p%s' % (device.split('/')[-1], - partition) - else: - mapped_device = device - - utils.execute('sudo mount %s %s' %(mapped_device, container_dir)) - - except Exception as e: - LOG.warn(_('Unable to mount container')) - if not partition is None: - # remove partitions - utils.execute('sudo kpartx -s %s' % device) + err = utils.execute('sudo', 'mount', mapped_device, container_dir) + if err: + raise exception.Error(_('Failed to mount filesystem: %s') + % err) _unlink_device(device, nbd) def destroy_container(target, instance, nbd=False): """Destroy the container once it terminates""" try: - utils.execute('sudo umount %s/rootfs' % target) + container_dir = '%s/rootfs' % target + utils.execute('sudo', 'umount', container_dir) + finally: image = os.path.join(FLAGS.instances_path, instance['name'], '' + 'disk') - except Exception as e: - LOG.warn(_('Unable to umount contianer')) + out, err = utils.execute('sudo', 'losetup', '--find', '--show', image) + device = out.strip() + if err: + raise execption.Error(_('Could not find loopback image: %s') + %err) + utils.execute('sudo', 'losetup', '--detach', device) + def _link_device(image, nbd): """Link image to device using loopback or nbd""" -- cgit From 8a41046dc7cafb19afb6719866b11681daaa9082 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Tue, 15 Mar 2011 09:48:21 +0100 Subject: Always put the ipv6 fallback in place. FLAGS.use_ipv6 does not exist yet when the firewall driver is instantiated and the iptables manager takes care not to fiddle with ipv6 if not enabled. --- nova/virt/libvirt_conn.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 03f046cbd..f87decaa0 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1597,9 +1597,8 @@ class IptablesFirewallDriver(FirewallDriver): self.iptables.ipv4['filter'].add_chain('sg-fallback') self.iptables.ipv4['filter'].add_rule('sg-fallback', '-j DROP') - if FLAGS.use_ipv6: - self.iptables.ipv6['filter'].add_chain('sg-fallback') - self.iptables.ipv6['filter'].add_rule('sg-fallback', '-j DROP') + self.iptables.ipv6['filter'].add_chain('sg-fallback') + self.iptables.ipv6['filter'].add_rule('sg-fallback', '-j DROP') def setup_basic_filtering(self, instance): """Use NWFilter from libvirt for this.""" -- cgit From 48d3dd7f9d2633d8955080b6dccc7c97bc8ef7c3 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Tue, 15 Mar 2011 07:56:26 -0400 Subject: Mount the right device --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index a3db1d882..2c0460f39 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -122,7 +122,7 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): to create the root filesystem for the container """ device = _link_device(image, nbd) - err = utils.execute('sudo', 'mount', mapped_device, container_dir) + err = utils.execute('sudo', 'mount', device, container_dir) if err: raise exception.Error(_('Failed to mount filesystem: %s') % err) -- cgit From f60c9d0da8171b09bd7971fea52e9e032f98a143 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Tue, 15 Mar 2011 08:05:45 -0400 Subject: Add comments about the destroy container function --- nova/virt/disk.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 2c0460f39..dd4352957 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -129,7 +129,11 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): _unlink_device(device, nbd) def destroy_container(target, instance, nbd=False): - """Destroy the container once it terminates""" + """Destroy the container once it terminates + + It will umount the container that is mounted, try to find the loopback + device associated with the container and delete it. + """ try: container_dir = '%s/rootfs' % target utils.execute('sudo', 'umount', container_dir) -- cgit From 3c10c1ee1bcc3f3aad90e4e28761d1413ab203a9 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Tue, 15 Mar 2011 09:36:02 -0400 Subject: Really delete the loop --- nova/virt/disk.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index dd4352957..a44995613 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -23,6 +23,7 @@ Includes injection of SSH PGP keys into authorized_keys file. """ import os +import string import tempfile import time @@ -138,13 +139,10 @@ def destroy_container(target, instance, nbd=False): container_dir = '%s/rootfs' % target utils.execute('sudo', 'umount', container_dir) finally: - image = os.path.join(FLAGS.instances_path, instance['name'], '' + 'disk') - out, err = utils.execute('sudo', 'losetup', '--find', '--show', image) - device = out.strip() - if err: - raise execption.Error(_('Could not find loopback image: %s') - %err) - utils.execute('sudo', 'losetup', '--detach', device) + for loop in os.popen('sudo losetup -a').readlines(): + if instance['name'] in loop: + device = string.split(loop, ':') + utils.execute('sudo', 'losetup', '--detach', device) def _link_device(image, nbd): -- cgit From e9ef6e04786a40d20f8022bec5d23d2e4503ce3a Mon Sep 17 00:00:00 2001 From: Mark Washenberger Date: Tue, 15 Mar 2011 17:56:00 -0400 Subject: s/onset_files/injected_files/g --- nova/virt/xenapi/vmops.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index d3fc335fe..488a61e8e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -137,19 +137,20 @@ class VMOps(object): LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.') % locals()) - def _inject_onset_files(): - onset_files = instance.onset_files - if onset_files: + def _inject_files(): + injected_files = instance.injected_files + if injected_files: # Check if this is a JSON-encoded string and convert if needed. - if isinstance(onset_files, basestring): + if isinstance(injected_files, basestring): try: - onset_files = json.loads(onset_files) + injected_files = json.loads(injected_files) except ValueError: - LOG.exception(_("Invalid value for onset_files: '%s'") - % onset_files) - onset_files = [] + LOG.exception( + _("Invalid value for injected_files: '%s'") + % injected_files) + injected_files = [] # Inject any files, if specified - for path, contents in instance.onset_files: + for path, contents in instance.injected_files: LOG.debug(_("Injecting file path: '%s'") % path) self.inject_file(instance, path, contents) # NOTE(armando): Do we really need to do this in virt? @@ -165,7 +166,7 @@ class VMOps(object): if state == power_state.RUNNING: LOG.debug(_('Instance %s: booted'), instance_name) timer.stop() - _inject_onset_files() + _inject_files() return True except Exception, exc: LOG.warn(exc) -- cgit From 74987666f89b4d15ffcf17b43b3752135ba08a65 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Mar 2011 18:48:17 -0500 Subject: A few fixes --- nova/virt/xenapi/vmops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index d1aaf998f..119d6dba8 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -304,7 +304,7 @@ class VMOps(object): try: # transfer the base copy template_vm_ref, template_vdi_uuids = self._get_snapshot(instance) - base_copy_uuid = template_vdi_uuids[1] + base_copy_uuid = template_vdi_uuids['snap'] vdi_ref, vm_vdi_rec = \ VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) cow_uuid = vm_vdi_rec['uuid'] @@ -319,7 +319,7 @@ class VMOps(object): self._session.wait_for_task(task, instance.id) # Now power down the instance and transfer the COW VHD - self._shutdown(instance, vm_ref, method='clean') + self._shutdown(instance, vm_ref) params = {'host': dest, 'vdi_uuid': cow_uuid, -- cgit From 39e722b58b87297aee770637f6a82ee1f206aecf Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Mar 2011 18:51:22 -0500 Subject: Tweak --- nova/virt/xenapi/vmops.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 119d6dba8..958201695 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -319,7 +319,7 @@ class VMOps(object): self._session.wait_for_task(task, instance.id) # Now power down the instance and transfer the COW VHD - self._shutdown(instance, vm_ref) + self._shutdown(instance, vm_ref, hard=False) params = {'host': dest, 'vdi_uuid': cow_uuid, @@ -447,7 +447,8 @@ class VMOps(object): """Shutdown an instance""" state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: - LOG.warn(_("VM %(vm)s already halted, skipping shutdown...") % + instance_name = instance.name + LOG.warn(_("VM %(instance_name)s already halted, skipping shutdown...") % locals()) return -- cgit From 9650e73db3e18f839f8abf7a47aebb6fbf8c9e36 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Tue, 15 Mar 2011 19:10:50 -0500 Subject: Plugin --- nova/virt/xenapi/vmops.py | 1 - 1 file changed, 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 958201695..cdc4a417c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -370,7 +370,6 @@ class VMOps(object): #TODO(mdietz): this will need to be adjusted for swap later task = self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) - vm_ref = VMHelper.lookup(self._session, instance.name) self._session.wait_for_task(task, instance.id) def reboot(self, instance): -- cgit From 016669543a1f6d4ffc281637ba98c6b6fe30be82 Mon Sep 17 00:00:00 2001 From: Thierry Carrez Date: Wed, 16 Mar 2011 10:38:48 +0100 Subject: Fix unknown exception error in euca-get-ajax-console --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7994e9547..d7bdc3faa 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -502,7 +502,7 @@ class LibvirtConnection(object): cmd = 'netcat', '0.0.0.0', port, '-w', '1' try: stdout, stderr = utils.execute(*cmd, process_input='') - except ProcessExecutionError: + except exception.ProcessExecutionError: return port raise Exception(_('Unable to find an open port')) -- cgit From ba35831c1f66c424e9495642ba23e9d2742a339e Mon Sep 17 00:00:00 2001 From: Christian Berendt Date: Wed, 16 Mar 2011 10:58:02 +0100 Subject: added correct path to cpu information (tested on a system with 1 installed cpu package) --- nova/virt/libvirt_conn.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7994e9547..9943b742a 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -984,18 +984,18 @@ class LibvirtConnection(object): xml = self._conn.getCapabilities() xml = libxml2.parseDoc(xml) - nodes = xml.xpathEval('//cpu') + nodes = xml.xpathEval('//host/cpu') if len(nodes) != 1: raise exception.Invalid(_("Invalid xml. '' must be 1," "but %d\n") % len(nodes) + xml.serialize()) cpu_info = dict() - cpu_info['arch'] = xml.xpathEval('//cpu/arch')[0].getContent() - cpu_info['model'] = xml.xpathEval('//cpu/model')[0].getContent() - cpu_info['vendor'] = xml.xpathEval('//cpu/vendor')[0].getContent() + cpu_info['arch'] = xml.xpathEval('//host/cpu/arch')[0].getContent() + cpu_info['model'] = xml.xpathEval('//host/cpu/model')[0].getContent() + cpu_info['vendor'] = xml.xpathEval('//host/cpu/vendor')[0].getContent() - topology_node = xml.xpathEval('//cpu/topology')[0].get_properties() + topology_node = xml.xpathEval('//host/cpu/topology')[0].get_properties() topology = dict() while topology_node != None: name = topology_node.get_name() @@ -1009,7 +1009,7 @@ class LibvirtConnection(object): raise exception.Invalid(_("Invalid xml: topology(%(topology)s) " "must have %(ks)s") % locals()) - feature_nodes = xml.xpathEval('//cpu/feature') + feature_nodes = xml.xpathEval('//host/cpu/feature') features = list() for nodes in feature_nodes: features.append(nodes.get_properties().getContent()) -- cgit From af2cae27930a3983c96a0b1705f828d65d4829cd Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Wed, 16 Mar 2011 12:18:15 +0100 Subject: Fix a couple of things that assume that libvirt == kvm/qemu. --- nova/virt/libvirt_conn.py | 42 +++++++++++++++++++++++++++--------------- 1 file changed, 27 insertions(+), 15 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7994e9547..96463d0f2 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -991,23 +991,35 @@ class LibvirtConnection(object): + xml.serialize()) cpu_info = dict() - cpu_info['arch'] = xml.xpathEval('//cpu/arch')[0].getContent() - cpu_info['model'] = xml.xpathEval('//cpu/model')[0].getContent() - cpu_info['vendor'] = xml.xpathEval('//cpu/vendor')[0].getContent() - topology_node = xml.xpathEval('//cpu/topology')[0].get_properties() + arch_nodes = xml.xpathEval('//cpu/arch') + if len(arch_nodes): + cpu_info['arch'] = arch_nodes[0].getContent() + + model_nodes = xml.xpathEval('//cpu/model') + if len(model_nodes): + cpu_info['model'] = model_nodes[0].getContent() + + vendor_nodes = xml.xpathEval('//cpu/vendor') + if len(vendor_nodes): + cpu_info['vendor'] = vendor_nodes[0].getContent() + + topology_nodes = xml.xpathEval('//cpu/topology') topology = dict() - while topology_node != None: - name = topology_node.get_name() - topology[name] = topology_node.getContent() - topology_node = topology_node.get_next() - - keys = ['cores', 'sockets', 'threads'] - tkeys = topology.keys() - if list(set(tkeys)) != list(set(keys)): - ks = ', '.join(keys) - raise exception.Invalid(_("Invalid xml: topology(%(topology)s) " - "must have %(ks)s") % locals()) + if len(topology_nodes): + topology_node = topology_nodes[0].get_properties() + while topology_node != None: + name = topology_node.get_name() + topology[name] = topology_node.getContent() + topology_node = topology_node.get_next() + + keys = ['cores', 'sockets', 'threads'] + tkeys = topology.keys() + if list(set(tkeys)) != list(set(keys)): + ks = ', '.join(keys) + raise exception.Invalid(_("Invalid xml: topology(%(topology)s) " + "must have %(ks)s") % locals()) + feature_nodes = xml.xpathEval('//cpu/feature') features = list() -- cgit From 2e81ce6bb5b1083220e7ae5c17113fd44465ddbf Mon Sep 17 00:00:00 2001 From: Koji Iida Date: Wed, 16 Mar 2011 21:17:19 +0900 Subject: Fix instance creation fail under use_ipv6=false and FlatManager --- nova/virt/libvirt_conn.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9efbb3342..a850bad87 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -660,11 +660,10 @@ class LibvirtConnection(object): if network_ref['injected']: admin_context = context.get_admin_context() address = db.instance_get_fixed_address(admin_context, inst['id']) - address_v6 = db.instance_get_fixed_address_v6(admin_context, - inst['id']) - gateway_v6 = network_ref['gateway_v6'] - if not gateway_v6: - gateway_v6 = "fd00::" + address_v6 = None + if FLAGS.use_ipv6: + address_v6 = db.instance_get_fixed_address_v6(admin_context, + inst['id']) interfaces_info = {'address': address, 'netmask': network_ref['netmask'], -- cgit From bb52b51d0e4f9b297dcc489562f38d1647e10856 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 16 Mar 2011 12:34:39 +0000 Subject: Adding unit test --- nova/virt/xenapi/fake.py | 67 +++++++++++++++++++++++++++++++++++++++++++---- nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 63 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index ba12d4d3a..2e8cd9c5c 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -61,7 +61,7 @@ from nova import log as logging _CLASSES = ['host', 'network', 'session', 'SR', 'VBD',\ - 'PBD', 'VDI', 'VIF', 'VM', 'task'] + 'PBD', 'VDI', 'VIF', 'PIF', 'VM', 'VLAN', 'task'] _db_content = {} @@ -103,7 +103,6 @@ def create_vm(name_label, status, 'is_control_domain': is_control_domain, }) - def destroy_vm(vm_ref): vm_rec = _db_content['VM'][vm_ref] @@ -178,6 +177,12 @@ def create_task(name_label): }) +def create_local_pifs(): + """Adds a PIF for each to the local database with VLAN=-1. + Do this one per host.""" + for host_ref in _db_content['host'].keys(): + _create_local_pif(host_ref) + def create_local_srs(): """Create an SR that looks like the one created on the local disk by default by the XenServer installer. Do this one per host.""" @@ -204,8 +209,18 @@ def _create_local_sr(host_ref): _db_content['SR'][sr_ref]['PBDs'] = [pbd_ref] return sr_ref +def _create_local_pif(host_ref): + pif_ref= _create_object('PIF', { + 'name-label': 'Fake PIF', + 'MAC': '00:11:22:33:44:55', + 'physical': True, + 'VLAN': -1, + 'device': 'fake0', + 'host_uuid': host_ref, + }) def _create_object(table, obj): + LOG.debug("ENTERING _create_object:%s", obj) ref = str(uuid.uuid4()) obj['uuid'] = str(uuid.uuid4()) _db_content[table][ref] = obj @@ -228,6 +243,24 @@ def _create_sr(table, obj): return sr_ref +def _create_vlan(pif_ref, vlan_num, network_ref): + LOG.debug("ENTERING FAKE CREATE VLAN") + pif_rec = get_record('PIF', pif_ref) + vlan_pif_ref = _create_object('PIF', { + 'name-label': 'Fake VLAN PIF', + 'MAC': '00:11:22:33:44:55', + 'physical': True, + 'VLAN': vlan_num, + 'device': pif_rec['device'], + 'host_uuid': pif_rec['host_uuid'], + }) + return _create_object('VLAN', { + 'tagged-pif': pif_ref, + 'untagged-pif': vlan_pif_ref, + 'tag': vlan_num + }) + + def get_all(table): return _db_content[table].keys() @@ -235,7 +268,6 @@ def get_all(table): def get_all_records(table): return _db_content[table] - def get_record(table, ref): if ref in _db_content[table]: return _db_content[table].get(ref) @@ -286,6 +318,26 @@ class SessionBase(object): rec['currently_attached'] = False rec['device'] = '' + def PIF_get_all_records_where(self, _1,_2): + # TODO (salvatore-orlando):filter table on _2 + return _db_content['PIF'] + + def VM_get_xenstore_data(self, _1, vm_ref): + return _db_content['VM'][vm_ref].get('xenstore_data', '') + + def VM_remove_from_xenstore_data(self, _1, vm_ref, key): + db_ref = _db_content['VM'][vm_ref] + if not 'xenstore_data' in db_ref: + return + db_ref['xenstore_data'][key] = None + + + def VM_add_to_xenstore_data(self, _1, vm_ref, key, value): + db_ref = _db_content['VM'][vm_ref] + if not 'xenstore_data' in db_ref: + db_ref['xenstore_data'] = {} + db_ref['xenstore_data'][key] = value + def host_compute_free_memory(self, _1, ref): #Always return 12GB available return 12 * 1024 * 1024 * 1024 @@ -431,12 +483,17 @@ class SessionBase(object): def _create(self, name, params): self._check_session(params) is_sr_create = name == 'SR.create' + LOG.debug("NAME:%s",name) + is_vlan_create = name == 'VLAN.create' # Storage Repositories have a different API - expected = is_sr_create and 10 or 2 + expected = is_sr_create and 10 or is_vlan_create and 4 or 2 self._check_arg_count(params, expected) (cls, _) = name.split('.') ref = is_sr_create and \ - _create_sr(cls, params) or _create_object(cls, params[1]) + _create_sr(cls, params) or \ + is_vlan_create and \ + _create_vlan(params[1],params[2],params[3]) or \ + _create_object(cls, params[1]) # Call hook to provide any fixups needed (ex. creating backrefs) after_hook = 'after_%s_create' % cls diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 0813c3db4..4bfef20f3 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -772,7 +772,7 @@ class VMOps(object): if network_ref: try: device = "1" if instance._rescue else "0" - except AttributeError: + except (AttributeError, KeyError): device = "0" VMHelper.create_vif( -- cgit From 8f9a5ecb7d3907456b9a77f3321ed09feb5c5f2f Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Wed, 16 Mar 2011 09:24:17 -0400 Subject: More execvp fallout --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index af2cbdce5..a79e0a065 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -599,7 +599,7 @@ class LibvirtConnection(object): if FLAGS.libvirt_type == 'lxc': container_dir = '%s/rootfs' % basepath(suffix='') - utils.execute('mkdir -p %s' % container_dir) + utils.execute('mkdir', '-p', container_dir) # NOTE(vish): No need add the suffix to console.log os.close(os.open(basepath('console.log', ''), -- cgit From 45ca7b71a8e749cbd9b7729b922190e9aaa53744 Mon Sep 17 00:00:00 2001 From: sateesh Date: Wed, 16 Mar 2011 21:54:02 +0530 Subject: * Updated document vmware_readme.rst to mention VLAN networking * Corrected docstrings as per pep0257 recommentations. * Stream-lined the comments. * Updated code with locals() where ever applicable. * VIM : It stands for VMware Virtual Infrastructure Methodology. We have used the terminology from VMware. we have added a question in FAQ inside vmware_readme.rst in doc/source * New fake db: vmwareapi fake module uses a different set of fields and hence the structures required are different. Ex: bridge : 'xenbr0' does not hold good for VMware environment and bridge : 'vmnic0' is used instead. Also return values varies, hence went for implementing separate fake db. * Now using eventlet library instead and removed io_utils.py from branch. * Now using glance.client.Client instead of homegrown code to talk to Glance server to handle images. * Corrected all mis-spelled function names and corresponding calls. Yeah, an auto-complete side-effect! --- nova/virt/vmwareapi/__init__.py | 2 +- nova/virt/vmwareapi/error_util.py | 48 ++++++---- nova/virt/vmwareapi/fake.py | 122 +++++++++++++------------ nova/virt/vmwareapi/network_utils.py | 28 +++--- nova/virt/vmwareapi/read_write_util.py | 145 ++++-------------------------- nova/virt/vmwareapi/vim.py | 59 ++++++------ nova/virt/vmwareapi/vim_util.py | 45 +++++----- nova/virt/vmwareapi/vm_util.py | 70 ++++++++------- nova/virt/vmwareapi/vmops.py | 159 ++++++++++++++++++--------------- nova/virt/vmwareapi/vmware_images.py | 109 ++++++++-------------- nova/virt/vmwareapi_conn.py | 83 +++++++++-------- 11 files changed, 396 insertions(+), 474 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/__init__.py b/nova/virt/vmwareapi/__init__.py index 6dbcc157a..d9b27de08 100644 --- a/nova/virt/vmwareapi/__init__.py +++ b/nova/virt/vmwareapi/__init__.py @@ -15,5 +15,5 @@ # License for the specific language governing permissions and limitations # under the License. """ -:mod:`vmwareapi` -- Nova support for VMware ESX/ESXi Server through vSphere API +:mod:`vmwareapi` -- Nova support for VMware ESX/ESXi Server through VMware API. """ diff --git a/nova/virt/vmwareapi/error_util.py b/nova/virt/vmwareapi/error_util.py index 3196b5038..cf92c3493 100644 --- a/nova/virt/vmwareapi/error_util.py +++ b/nova/virt/vmwareapi/error_util.py @@ -16,7 +16,7 @@ # under the License. """ -Exception classes and SOAP response error checking module +Exception classes and SOAP response error checking module. """ FAULT_NOT_AUTHENTICATED = "NotAuthenticated" @@ -24,7 +24,7 @@ FAULT_ALREADY_EXISTS = "AlreadyExists" class VimException(Exception): - """The VIM Exception class""" + """The VIM Exception class.""" def __init__(self, exception_summary, excep): Exception.__init__(self) @@ -36,17 +36,17 @@ class VimException(Exception): class SessionOverLoadException(VimException): - """Session Overload Exception""" + """Session Overload Exception.""" pass class VimAttributeError(VimException): - """VI Attribute Error""" + """VI Attribute Error.""" pass class VimFaultException(Exception): - """The VIM Fault exception class""" + """The VIM Fault exception class.""" def __init__(self, fault_list, excep): Exception.__init__(self) @@ -58,23 +58,37 @@ class VimFaultException(Exception): class FaultCheckers: - """Methods for fault checking of SOAP response. Per Method error handlers + """ + Methods for fault checking of SOAP response. Per Method error handlers for which we desire error checking are defined. SOAP faults are - embedded in the SOAP as a property and not as a SOAP fault.""" + embedded in the SOAP messages as properties and not as SOAP faults. + """ @classmethod def retrieveproperties_fault_checker(self, resp_obj): - """Checks the RetrieveProperties response for errors. Certain faults - are sent as a part of the SOAP body as property of missingSet. - For example NotAuthenticated fault""" + """ + Checks the RetrieveProperties response for errors. Certain faults + are sent as part of the SOAP body as property of missingSet. + For example NotAuthenticated fault. + """ fault_list = [] - for obj_cont in resp_obj: - if hasattr(obj_cont, "missingSet"): - for missing_elem in obj_cont.missingSet: - fault_type = missing_elem.fault.fault.__class__.__name__ - #Fault needs to be added to the type of fault for - #uniformity in error checking as SOAP faults define - fault_list.append(fault_type) + if not resp_obj: + # This is the case when the session has timed out. ESX SOAP server + # sends an empty RetrievePropertiesResponse. Normally missingSet in + # the returnval field has the specifics about the error, but that's + # not the case with a timed out idle session. It is as bad as a + # terminated session for we cannot use the session. So setting + # fault to NotAuthenticated fault. + fault_list = ["NotAuthenticated"] + else: + for obj_cont in resp_obj: + if hasattr(obj_cont, "missingSet"): + for missing_elem in obj_cont.missingSet: + fault_type = \ + missing_elem.fault.fault.__class__.__name__ + # Fault needs to be added to the type of fault for + # uniformity in error checking as SOAP faults define + fault_list.append(fault_type) if fault_list: exc_msg_list = ', '.join(fault_list) raise VimFaultException(fault_list, Exception(_("Error(s) %s " diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py index e03d74cf8..38585c714 100644 --- a/nova/virt/vmwareapi/fake.py +++ b/nova/virt/vmwareapi/fake.py @@ -39,14 +39,14 @@ LOG = logging.getLogger("nova.virt.vmwareapi.fake") def log_db_contents(msg=None): - """ Log DB Contents""" + """Log DB Contents.""" text = msg or "" content = pformat(_db_content) LOG.debug(_("%(text)s: _db_content => %(content)s") % locals()) def reset(): - """ Resets the db contents """ + """Resets the db contents.""" for c in _CLASSES: #We fake the datastore by keeping the file references as a list of #names in the db @@ -63,18 +63,18 @@ def reset(): def cleanup(): - """ Clear the db contents """ + """Clear the db contents.""" for c in _CLASSES: _db_content[c] = {} def _create_object(table, obj): - """ Create an object in the db """ + """Create an object in the db.""" _db_content[table][obj.obj] = obj def _get_objects(type): - """ Get objects of the type """ + """Get objects of the type.""" lst_objs = [] for key in _db_content[type]: lst_objs.append(_db_content[type][key]) @@ -82,7 +82,7 @@ def _get_objects(type): class Prop(object): - """ Property Object base class """ + """Property Object base class.""" def __init__(self): self.name = None @@ -96,10 +96,10 @@ class Prop(object): class ManagedObject(object): - """ Managed Data Object base class """ + """Managed Data Object base class.""" def __init__(self, name="ManagedObject", obj_ref=None): - """ Sets the obj property which acts as a reference to the object""" + """Sets the obj property which acts as a reference to the object.""" object.__setattr__(self, 'objName', name) if obj_ref is None: obj_ref = str(uuid.uuid4()) @@ -107,14 +107,18 @@ class ManagedObject(object): object.__setattr__(self, 'propSet', []) def set(self, attr, val): - """ Sets an attribute value. Not using the __setattr__ directly for we + """ + Sets an attribute value. Not using the __setattr__ directly for we want to set attributes of the type 'a.b.c' and using this function - class we set the same """ + class we set the same. + """ self.__setattr__(attr, val) def get(self, attr): - """ Gets an attribute. Used as an intermediary to get nested - property like 'a.b.c' value """ + """ + Gets an attribute. Used as an intermediary to get nested + property like 'a.b.c' value. + """ return self.__getattr__(attr) def __setattr__(self, attr, val): @@ -138,7 +142,7 @@ class ManagedObject(object): class DataObject(object): - """ Data object base class """ + """Data object base class.""" def __init__(self): pass @@ -151,30 +155,32 @@ class DataObject(object): class VirtualDisk(DataObject): - """ Virtual Disk class. Does nothing special except setting + """ + Virtual Disk class. Does nothing special except setting __class__.__name__ to 'VirtualDisk'. Refer place where __class__.__name__ - is used in the code """ + is used in the code. + """ def __init__(self): DataObject.__init__(self) class VirtualDiskFlatVer2BackingInfo(DataObject): - """ VirtualDiskFlatVer2BackingInfo class """ + """VirtualDiskFlatVer2BackingInfo class.""" def __init__(self): DataObject.__init__(self) class VirtualLsiLogicController(DataObject): - """ VirtualLsiLogicController class """ + """VirtualLsiLogicController class.""" def __init__(self): DataObject.__init__(self) class VirtualMachine(ManagedObject): - """ Virtual Machine class """ + """Virtual Machine class.""" def __init__(self, **kwargs): ManagedObject.__init__(self, "VirtualMachine") @@ -195,8 +201,10 @@ class VirtualMachine(ManagedObject): self.set("config.extraConfig", kwargs.get("extra_config", None)) def reconfig(self, factory, val): - """ Called to reconfigure the VM. Actually customizes the property - setting of the Virtual Machine object """ + """ + Called to reconfigure the VM. Actually customizes the property + setting of the Virtual Machine object. + """ try: #Case of Reconfig of VM to attach disk controller_key = val.deviceChange[1].device.controllerKey @@ -220,7 +228,7 @@ class VirtualMachine(ManagedObject): class Network(ManagedObject): - """ Network class """ + """Network class.""" def __init__(self): ManagedObject.__init__(self, "Network") @@ -228,7 +236,7 @@ class Network(ManagedObject): class ResourcePool(ManagedObject): - """ Resource Pool class """ + """Resource Pool class.""" def __init__(self): ManagedObject.__init__(self, "ResourcePool") @@ -236,7 +244,7 @@ class ResourcePool(ManagedObject): class Datastore(ManagedObject): - """ Datastore class """ + """Datastore class.""" def __init__(self): ManagedObject.__init__(self, "Datastore") @@ -245,7 +253,7 @@ class Datastore(ManagedObject): class HostNetworkSystem(ManagedObject): - """ HostNetworkSystem class """ + """HostNetworkSystem class.""" def __init__(self): ManagedObject.__init__(self, "HostNetworkSystem") @@ -261,7 +269,7 @@ class HostNetworkSystem(ManagedObject): class HostSystem(ManagedObject): - """ Host System class """ + """Host System class.""" def __init__(self): ManagedObject.__init__(self, "HostSystem") @@ -302,7 +310,7 @@ class HostSystem(ManagedObject): self.set("config.network.portgroup", host_pg) def _add_port_group(self, spec): - """ Adds a port group to the host system object in the db """ + """Adds a port group to the host system object in the db.""" pg_name = spec.name vswitch_name = spec.vswitchName vlanid = spec.vlanId @@ -328,7 +336,7 @@ class HostSystem(ManagedObject): class Datacenter(ManagedObject): - """ Datacenter class """ + """Datacenter class.""" def __init__(self): ManagedObject.__init__(self, "Datacenter") @@ -343,7 +351,7 @@ class Datacenter(ManagedObject): class Task(ManagedObject): - """ Task class """ + """Task class.""" def __init__(self, task_name, state="running"): ManagedObject.__init__(self, "Task") @@ -390,12 +398,12 @@ def create_task(task_name, state="running"): def _add_file(file_path): - """ Adds a file reference to the db """ + """Adds a file reference to the db.""" _db_content["files"].append(file_path) def _remove_file(file_path): - """ Removes a file reference from the db """ + """Removes a file reference from the db.""" if _db_content.get("files", None) is None: raise exception.NotFound(_("No files have been added yet")) #Check if the remove is for a single file object or for a folder @@ -415,7 +423,7 @@ def _remove_file(file_path): def fake_fetch_image(image, instance, **kwargs): - """Fakes fetch image call. Just adds a reference to the db for the file """ + """Fakes fetch image call. Just adds a reference to the db for the file.""" ds_name = kwargs.get("datastore_name") file_path = kwargs.get("file_path") ds_file_path = "[" + ds_name + "] " + file_path @@ -423,19 +431,19 @@ def fake_fetch_image(image, instance, **kwargs): def fake_upload_image(image, instance, **kwargs): - """Fakes the upload of an image """ + """Fakes the upload of an image.""" pass def fake_get_vmdk_size_and_properties(image_id, instance): - """ Fakes the file size and properties fetch for the image file """ + """Fakes the file size and properties fetch for the image file.""" props = {"vmware_ostype": "otherGuest", "vmware_adaptertype": "lsiLogic"} return _FAKE_FILE_SIZE, props def _get_vm_mdo(vm_ref): - """ Gets the Virtual Machine with the ref from the db """ + """Gets the Virtual Machine with the ref from the db.""" if _db_content.get("VirtualMachine", None) is None: raise exception.NotFound(_("There is no VM registered")) if vm_ref not in _db_content.get("VirtualMachine"): @@ -445,22 +453,24 @@ def _get_vm_mdo(vm_ref): class FakeFactory(object): - """ Fake factory class for the suds client """ + """Fake factory class for the suds client.""" def __init__(self): pass def create(self, obj_name): - """ Creates a namespace object """ + """Creates a namespace object.""" return DataObject() class FakeVim(object): - """Fake VIM Class""" + """Fake VIM Class.""" def __init__(self, protocol="https", host="localhost", trace=None): - """ Initializes the suds client object, sets the service content - contents and the cookies for the session """ + """ + Initializes the suds client object, sets the service content + contents and the cookies for the session. + """ self._session = None self.client = DataObject() self.client.factory = FakeFactory() @@ -490,7 +500,7 @@ class FakeVim(object): return "Fake VIM Object" def _login(self): - """ Logs in and sets the session object in the db """ + """Logs in and sets the session object in the db.""" self._session = str(uuid.uuid4()) session = DataObject() session.key = self._session @@ -498,7 +508,7 @@ class FakeVim(object): return session def _logout(self): - """ Logs out and remove the session object ref from the db """ + """Logs out and remove the session object ref from the db.""" s = self._session self._session = None if s not in _db_content['session']: @@ -508,14 +518,14 @@ class FakeVim(object): del _db_content['session'][s] def _terminate_session(self, *args, **kwargs): - """ Terminates a session """ + """Terminates a session.""" s = kwargs.get("sessionId")[0] if s not in _db_content['session']: return del _db_content['session'][s] def _check_session(self): - """ Checks if the session is active """ + """Checks if the session is active.""" if (self._session is None or self._session not in _db_content['session']): LOG.debug(_("Session is faulty")) @@ -524,7 +534,7 @@ class FakeVim(object): _("Session Invalid")) def _create_vm(self, method, *args, **kwargs): - """ Creates and registers a VM object with the Host System """ + """Creates and registers a VM object with the Host System.""" config_spec = kwargs.get("config") ds = _db_content["Datastore"][_db_content["Datastore"].keys()[0]] vm_dict = {"name": config_spec.name, @@ -539,7 +549,7 @@ class FakeVim(object): return task_mdo.obj def _reconfig_vm(self, method, *args, **kwargs): - """ Reconfigures a VM and sets the properties supplied """ + """Reconfigures a VM and sets the properties supplied.""" vm_ref = args[0] vm_mdo = _get_vm_mdo(vm_ref) vm_mdo.reconfig(self.client.factory, kwargs.get("spec")) @@ -547,7 +557,7 @@ class FakeVim(object): return task_mdo.obj def _create_copy_disk(self, method, vmdk_file_path): - """ Creates/copies a vmdk file object in the datastore """ + """Creates/copies a vmdk file object in the datastore.""" # We need to add/create both .vmdk and .-flat.vmdk files flat_vmdk_file_path = \ vmdk_file_path.replace(".vmdk", "-flat.vmdk") @@ -557,12 +567,12 @@ class FakeVim(object): return task_mdo.obj def _snapshot_vm(self, method): - """ Snapshots a VM. Here we do nothing for faking sake """ + """Snapshots a VM. Here we do nothing for faking sake.""" task_mdo = create_task(method, "success") return task_mdo.obj def _delete_disk(self, method, *args, **kwargs): - """ Deletes .vmdk and -flat.vmdk files corresponding to the VM """ + """Deletes .vmdk and -flat.vmdk files corresponding to the VM.""" vmdk_file_path = kwargs.get("name") flat_vmdk_file_path = \ vmdk_file_path.replace(".vmdk", "-flat.vmdk") @@ -572,23 +582,23 @@ class FakeVim(object): return task_mdo.obj def _delete_file(self, method, *args, **kwargs): - """ Deletes a file from the datastore """ + """Deletes a file from the datastore.""" _remove_file(kwargs.get("name")) task_mdo = create_task(method, "success") return task_mdo.obj def _just_return(self): - """ Fakes a return """ + """Fakes a return.""" return def _unregister_vm(self, method, *args, **kwargs): - """ Unregisters a VM from the Host System """ + """Unregisters a VM from the Host System.""" vm_ref = args[0] _get_vm_mdo(vm_ref) del _db_content["VirtualMachine"][vm_ref] def _search_ds(self, method, *args, **kwargs): - """ Searches the datastore for a file """ + """Searches the datastore for a file.""" ds_path = kwargs.get("datastorePath") if _db_content.get("files", None) is None: raise exception.NotFound(_("No files have been added yet")) @@ -600,14 +610,14 @@ class FakeVim(object): return task_mdo.obj def _make_dir(self, method, *args, **kwargs): - """ Creates a directory in the datastore """ + """Creates a directory in the datastore.""" ds_path = kwargs.get("name") if _db_content.get("files", None) is None: raise exception.NotFound(_("No files have been added yet")) _db_content["files"].append(ds_path) def _set_power_state(self, method, vm_ref, pwr_state="poweredOn"): - """ Sets power state for the VM """ + """Sets power state for the VM.""" if _db_content.get("VirtualMachine", None) is None: raise exception.NotFound(_(" No Virtual Machine has been " "registered yet")) @@ -620,7 +630,7 @@ class FakeVim(object): return task_mdo.obj def _retrieve_properties(self, method, *args, **kwargs): - """ Retrieves properties based on the type """ + """Retrieves properties based on the type.""" spec_set = kwargs.get("specSet")[0] type = spec_set.propSet[0].type properties = spec_set.propSet[0].pathSet @@ -654,7 +664,7 @@ class FakeVim(object): return lst_ret_objs def _add_port_group(self, method, *args, **kwargs): - """ Adds a port group to the host system """ + """Adds a port group to the host system.""" host_mdo = \ _db_content["HostSystem"][_db_content["HostSystem"].keys()[0]] host_mdo._add_port_group(kwargs.get("portgrp")) diff --git a/nova/virt/vmwareapi/network_utils.py b/nova/virt/vmwareapi/network_utils.py index 36fa98996..8d023d580 100644 --- a/nova/virt/vmwareapi/network_utils.py +++ b/nova/virt/vmwareapi/network_utils.py @@ -16,7 +16,7 @@ # under the License. """ -Utility functions for ESX Networking +Utility functions for ESX Networking. """ from nova import exception @@ -32,8 +32,10 @@ class NetworkHelper: @classmethod def get_network_with_the_name(cls, session, network_name="vmnet0"): - """ Gets reference to the network whose name is passed as the - argument. """ + """ + Gets reference to the network whose name is passed as the + argument. + """ hostsystems = session._call_method(vim_util, "get_objects", "HostSystem", ["network"]) vm_networks_ret = hostsystems[0].propSet[0].val @@ -44,7 +46,7 @@ class NetworkHelper: return None vm_networks = vm_networks_ret.ManagedObjectReference networks = session._call_method(vim_util, - "get_properites_for_a_collection_of_objects", + "get_properties_for_a_collection_of_objects", "Network", vm_networks, ["summary.name"]) for network in networks: if network.propSet[0].val == network_name: @@ -53,8 +55,10 @@ class NetworkHelper: @classmethod def get_vswitch_for_vlan_interface(cls, session, vlan_interface): - """ Gets the vswitch associated with the physical - network adapter with the name supplied""" + """ + Gets the vswitch associated with the physical network adapter + with the name supplied. + """ #Get the list of vSwicthes on the Host System host_mor = session._call_method(vim_util, "get_objects", "HostSystem")[0].obj @@ -77,7 +81,7 @@ class NetworkHelper: @classmethod def check_if_vlan_interface_exists(cls, session, vlan_interface): - """ Checks if the vlan_inteface exists on the esx host """ + """Checks if the vlan_inteface exists on the esx host.""" host_net_system_mor = session._call_method(vim_util, "get_objects", "HostSystem", ["configManager.networkSystem"])[0].propSet[0].val physical_nics_ret = session._call_method(vim_util, @@ -93,8 +97,8 @@ class NetworkHelper: return False @classmethod - def get_vlanid_and_vswicth_for_portgroup(cls, session, pg_name): - """ Get the vlan id and vswicth associated with the port group """ + def get_vlanid_and_vswitch_for_portgroup(cls, session, pg_name): + """Get the vlan id and vswicth associated with the port group.""" host_mor = session._call_method(vim_util, "get_objects", "HostSystem")[0].obj port_grps_on_host_ret = session._call_method(vim_util, @@ -113,8 +117,10 @@ class NetworkHelper: @classmethod def create_port_group(cls, session, pg_name, vswitch_name, vlan_id=0): - """ Creates a port group on the host system with the vlan tags - supplied. VLAN id 0 means no vlan id association """ + """ + Creates a port group on the host system with the vlan tags + supplied. VLAN id 0 means no vlan id association. + """ client_factory = session._get_vim().client.factory add_prt_grp_spec = vm_util.get_add_vswitch_port_group_spec( client_factory, diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py index 37f80c133..52ed6f9ac 100644 --- a/nova/virt/vmwareapi/read_write_util.py +++ b/nova/virt/vmwareapi/read_write_util.py @@ -15,7 +15,7 @@ # License for the specific language governing permissions and limitations # under the License. -""" Classes to handle image files +"""Classes to handle image files. Collection of classes to handle image upload/download to/from Image service (like Glance image storage and retrieval service) from/to ESX/ESXi server. @@ -29,8 +29,6 @@ import urlparse from nova import flags from nova import log as logging -from nova import utils -from nova.auth.manager import AuthManager FLAGS = flags.FLAGS @@ -41,145 +39,34 @@ USER_AGENT = "OpenStack-ESX-Adapter" LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util") -class ImageServiceFile: - """The base image service class""" - - def __init__(self, file_handle): - self.eof = False - self.file_handle = file_handle - - def write(self, data): - """Write data to the file""" - raise NotImplementedError - - def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data from the file""" - raise NotImplementedError - - def get_size(self): - """Get the size of the file whose data is to be read""" - raise NotImplementedError - - def set_eof(self, eof): - """Set the end of file marker""" - self.eof = eof - - def get_eof(self): - """Check if the file end has been reached or not""" - return self.eof - - def close(self): - """Close the file handle""" - try: - self.file_handle.close() - except Exception: - pass - - def get_image_properties(self): - """Get the image properties""" - raise NotImplementedError - - def __del__(self): - """Close the file handle on garbage collection""" - self.close() - - -class GlanceHTTPWriteFile(ImageServiceFile): - """Glance file write handler class""" - - def __init__(self, host, port, image_id, file_size, os_type, adapter_type, - version=1, scheme="http"): - base_url = "%s://%s:%s/images/%s" % (scheme, host, port, image_id) - (scheme, netloc, path, params, query, fragment) = \ - urlparse.urlparse(base_url) - if scheme == "http": - conn = httplib.HTTPConnection(netloc) - elif scheme == "https": - conn = httplib.HTTPSConnection(netloc) - conn.putrequest("PUT", path) - conn.putheader("User-Agent", USER_AGENT) - conn.putheader("Content-Length", file_size) - conn.putheader("Content-Type", "application/octet-stream") - conn.putheader("x-image-meta-store", "file") - conn.putheader("x-image-meta-is_public", "True") - conn.putheader("x-image-meta-type", "raw") - conn.putheader("x-image-meta-size", file_size) - conn.putheader("x-image-meta-property-kernel_id", "") - conn.putheader("x-image-meta-property-ramdisk_id", "") - conn.putheader("x-image-meta-property-vmware_ostype", os_type) - conn.putheader("x-image-meta-property-vmware_adaptertype", - adapter_type) - conn.putheader("x-image-meta-property-vmware_image_version", version) - conn.endheaders() - ImageServiceFile.__init__(self, conn) - - def write(self, data): - """Write data to the file""" - self.file_handle.send(data) - - -class GlanceHTTPReadFile(ImageServiceFile): - """Glance file read handler class""" - - def __init__(self, host, port, image_id, scheme="http"): - base_url = "%s://%s:%s/images/%s" % (scheme, host, port, - urllib.pathname2url(image_id)) - headers = {'User-Agent': USER_AGENT} - request = urllib2.Request(base_url, None, headers) - conn = urllib2.urlopen(request) - ImageServiceFile.__init__(self, conn) - - def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data""" - return self.file_handle.read(chunk_size) - - def get_size(self): - """Get the size of the file to be read""" - return self.file_handle.headers.get("X-Image-Meta-Size", -1) - - def get_image_properties(self): - """Get the image properties like say OS Type and the - Adapter Type - """ - return {"vmware_ostype": - self.file_handle.headers.get( - "X-Image-Meta-Property-Vmware_ostype"), - "vmware_adaptertype": - self.file_handle.headers.get( - "X-Image-Meta-Property-Vmware_adaptertype"), - "vmware_image_version": - self.file_handle.headers.get( - "X-Image-Meta-Property-Vmware_image_version")} - - class VMwareHTTPFile(object): - """Base class for HTTP file""" + """Base class for HTTP file.""" def __init__(self, file_handle): self.eof = False self.file_handle = file_handle def set_eof(self, eof): - """Set the end of file marker""" + """Set the end of file marker.""" self.eof = eof def get_eof(self): - """Check if the end of file has been reached""" + """Check if the end of file has been reached.""" return self.eof def close(self): - """Close the file handle""" + """Close the file handle.""" try: self.file_handle.close() except Exception: pass def __del__(self): - """Close the file handle on garbage collection""" + """Close the file handle on garbage collection.""" self.close() def _build_vim_cookie_headers(self, vim_cookies): - """Build ESX host session cookie headers""" + """Build ESX host session cookie headers.""" cookie_header = "" for vim_cookie in vim_cookies: cookie_header = vim_cookie.name + "=" + vim_cookie.value @@ -187,20 +74,20 @@ class VMwareHTTPFile(object): return cookie_header def write(self, data): - """Write data to the file""" + """Write data to the file.""" raise NotImplementedError def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data""" + """Read a chunk of data.""" raise NotImplementedError def get_size(self): - """Get size of the file to be read""" + """Get size of the file to be read.""" raise NotImplementedError class VMWareHTTPWriteFile(VMwareHTTPFile): - """VMWare file write handler class""" + """VMWare file write handler class.""" def __init__(self, host, data_center_name, datastore_name, cookies, file_path, file_size, scheme="https"): @@ -222,11 +109,11 @@ class VMWareHTTPWriteFile(VMwareHTTPFile): VMwareHTTPFile.__init__(self, conn) def write(self, data): - """Write to the file""" + """Write to the file.""" self.file_handle.send(data) def close(self): - """Get the response and close the connection""" + """Get the response and close the connection.""" try: self.conn.getresponse() except Exception, excep: @@ -236,7 +123,7 @@ class VMWareHTTPWriteFile(VMwareHTTPFile): class VmWareHTTPReadFile(VMwareHTTPFile): - """VMWare file read handler class""" + """VMWare file read handler class.""" def __init__(self, host, data_center_name, datastore_name, cookies, file_path, scheme="https"): @@ -251,9 +138,9 @@ class VmWareHTTPReadFile(VMwareHTTPFile): VMwareHTTPFile.__init__(self, conn) def read(self, chunk_size=READ_CHUNKSIZE): - """Read a chunk of data""" + """Read a chunk of data.""" return self.file_handle.read(chunk_size) def get_size(self): - """Get size of the file to be read""" + """Get size of the file to be read.""" return self.file_handle.headers.get("Content-Length", -1) diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index cea65e198..3430822e1 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -16,7 +16,7 @@ # under the License. """ -Classes for making VMware VI SOAP calls +Classes for making VMware VI SOAP calls. """ import httplib @@ -37,49 +37,50 @@ FLAGS = flags.FLAGS flags.DEFINE_string('vmwareapi_wsdl_loc', None, 'VIM Service WSDL Location' - 'E.g http:///vimService.wsdl' + 'e.g http:///vimService.wsdl' 'Due to a bug in vSphere ESX 4.1 default wsdl' - 'Read the readme for vmware to setup') + 'Refer readme-vmware to setup') class VIMMessagePlugin(MessagePlugin): def addAttributeForValue(self, node): - #suds does not handle AnyType properly - #VI SDK requires type attribute to be set when AnyType is used + # suds does not handle AnyType properly. + # VI SDK requires type attribute to be set when AnyType is used if node.name == 'value': node.set('xsi:type', 'xsd:string') def marshalled(self, context): - """Suds will send the specified soap envelope. + """suds will send the specified soap envelope. Provides the plugin with the opportunity to prune empty - nodes and fixup nodes before sending it to the server + nodes and fixup nodes before sending it to the server. """ - #suds builds the entire request object based on the wsdl schema - #VI SDK throws server errors if optional SOAP nodes are sent without - #values. E.g as opposed to test + # suds builds the entire request object based on the wsdl schema. + # VI SDK throws server errors if optional SOAP nodes are sent without + # values, e.g. as opposed to test context.envelope.prune() context.envelope.walk(self.addAttributeForValue) class Vim: - """The VIM Object""" + """The VIM Object.""" def __init__(self, protocol="https", host="localhost"): """ + Creates the necessary Communication interfaces and gets the + ServiceContent for initiating SOAP transactions. + protocol: http or https host : ESX IPAddress[:port] or ESX Hostname[:port] - Creates the necessary Communication interfaces, Gets the - ServiceContent for initiating SOAP transactions """ self._protocol = protocol self._host_name = host wsdl_url = FLAGS.vmwareapi_wsdl_loc if wsdl_url is None: raise Exception(_("Must specify vmwareapi_wsdl_loc")) - #Use this when VMware fixes their faulty wsdl + # Use this when VMware fixes their faulty wsdl #wsdl_url = '%s://%s/sdk/vimService.wsdl' % (self._protocol, # self._host_name) url = '%s://%s/sdk' % (self._protocol, self._host_name) @@ -89,37 +90,41 @@ class Vim: self.RetrieveServiceContent("ServiceInstance") def get_service_content(self): - """Gets the service content object""" + """Gets the service content object.""" return self._service_content def __getattr__(self, attr_name): - """Makes the API calls and gets the result""" + """Makes the API calls and gets the result.""" try: return object.__getattr__(self, attr_name) except AttributeError: def vim_request_handler(managed_object, **kwargs): - """managed_object : Managed Object Reference or Managed - Object Name - **kw : Keyword arguments of the call """ - #Dynamic handler for VI SDK Calls + Builds the SOAP message and parses the response for fault + checking and other errors. + + managed_object : Managed Object Reference or Managed + Object Name + **kwargs : Keyword arguments of the call + """ + # Dynamic handler for VI SDK Calls try: request_mo = \ self._request_managed_object_builder(managed_object) request = getattr(self.client.service, attr_name) response = request(request_mo, **kwargs) - #To check for the faults that are part of the message body - #and not returned as Fault object response from the ESX - #SOAP server + # To check for the faults that are part of the message body + # and not returned as Fault object response from the ESX + # SOAP server if hasattr(error_util.FaultCheckers, attr_name.lower() + "_fault_checker"): fault_checker = getattr(error_util.FaultCheckers, attr_name.lower() + "_fault_checker") fault_checker(response) return response - #Catch the VimFaultException that is raised by the fault - #check of the SOAP response + # Catch the VimFaultException that is raised by the fault + # check of the SOAP response except error_util.VimFaultException, excep: raise except WebFault, excep: @@ -155,8 +160,8 @@ class Vim: return vim_request_handler def _request_managed_object_builder(self, managed_object): - """Builds the request managed object""" - #Request Managed Object Builder + """Builds the request managed object.""" + # Request Managed Object Builder if type(managed_object) == type(""): mo = Property(managed_object) mo._type = managed_object diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py index 20117b04c..709b54e12 100644 --- a/nova/virt/vmwareapi/vim_util.py +++ b/nova/virt/vmwareapi/vim_util.py @@ -16,19 +16,19 @@ # under the License. """ -The VMware API utility module +The VMware API utility module. """ -def build_selcetion_spec(client_factory, name): - """ Builds the selection spec """ +def build_selection_spec(client_factory, name): + """Builds the selection spec.""" sel_spec = client_factory.create('ns0:SelectionSpec') sel_spec.name = name return sel_spec def build_traversal_spec(client_factory, name, type, path, skip, select_set): - """ Builds the traversal spec object """ + """Builds the traversal spec object.""" traversal_spec = client_factory.create('ns0:TraversalSpec') traversal_spec.name = name traversal_spec.type = type @@ -39,9 +39,11 @@ def build_traversal_spec(client_factory, name, type, path, skip, select_set): def build_recursive_traversal_spec(client_factory): - """ Builds the Recursive Traversal Spec to traverse the object managed - object hierarchy """ - visit_folders_select_spec = build_selcetion_spec(client_factory, + """ + Builds the Recursive Traversal Spec to traverse the object managed + object hierarchy. + """ + visit_folders_select_spec = build_selection_spec(client_factory, "visitFolders") #For getting to hostFolder from datacnetr dc_to_hf = build_traversal_spec(client_factory, "dc_to_hf", "Datacenter", @@ -64,8 +66,8 @@ def build_recursive_traversal_spec(client_factory): cr_to_ds = build_traversal_spec(client_factory, "cr_to_ds", "ComputeResource", "datastore", False, []) - rp_to_rp_select_spec = build_selcetion_spec(client_factory, "rp_to_rp") - rp_to_vm_select_spec = build_selcetion_spec(client_factory, "rp_to_vm") + rp_to_rp_select_spec = build_selection_spec(client_factory, "rp_to_rp") + rp_to_vm_select_spec = build_selection_spec(client_factory, "rp_to_vm") #For getting to resource pool from Compute Resource cr_to_rp = build_traversal_spec(client_factory, "cr_to_rp", "ComputeResource", "resourcePool", False, @@ -94,7 +96,7 @@ def build_recursive_traversal_spec(client_factory): def build_property_spec(client_factory, type="VirtualMachine", properties_to_collect=["name"], all_properties=False): - """Builds the Property Spec""" + """Builds the Property Spec.""" property_spec = client_factory.create('ns0:PropertySpec') property_spec.all = all_properties property_spec.pathSet = properties_to_collect @@ -103,7 +105,7 @@ def build_property_spec(client_factory, type="VirtualMachine", def build_object_spec(client_factory, root_folder, traversal_specs): - """Builds the object Spec""" + """Builds the object Spec.""" object_spec = client_factory.create('ns0:ObjectSpec') object_spec.obj = root_folder object_spec.skip = False @@ -112,7 +114,7 @@ def build_object_spec(client_factory, root_folder, traversal_specs): def build_property_filter_spec(client_factory, property_specs, object_specs): - """Builds the Property Filter Spec""" + """Builds the Property Filter Spec.""" property_filter_spec = client_factory.create('ns0:PropertyFilterSpec') property_filter_spec.propSet = property_specs property_filter_spec.objectSet = object_specs @@ -120,7 +122,7 @@ def build_property_filter_spec(client_factory, property_specs, object_specs): def get_object_properties(vim, collector, mobj, type, properties): - """Gets the properties of the Managed object specified""" + """Gets the properties of the Managed object specified.""" client_factory = vim.client.factory if mobj is None: return None @@ -141,7 +143,7 @@ def get_object_properties(vim, collector, mobj, type, properties): def get_dynamic_property(vim, mobj, type, property_name): - """Gets a particular property of the Managed Object""" + """Gets a particular property of the Managed Object.""" obj_content = \ get_object_properties(vim, None, mobj, type, [property_name]) property_value = None @@ -153,7 +155,7 @@ def get_dynamic_property(vim, mobj, type, property_name): def get_objects(vim, type, properties_to_collect=["name"], all=False): - """Gets the list of objects of the type specified""" + """Gets the list of objects of the type specified.""" client_factory = vim.client.factory object_spec = build_object_spec(client_factory, vim.get_service_content().rootFolder, @@ -169,7 +171,7 @@ def get_objects(vim, type, properties_to_collect=["name"], all=False): def get_prop_spec(client_factory, type, properties): - """Builds the Property Spec Object""" + """Builds the Property Spec Object.""" prop_spec = client_factory.create('ns0:PropertySpec') prop_spec.type = type prop_spec.pathSet = properties @@ -177,7 +179,7 @@ def get_prop_spec(client_factory, type, properties): def get_obj_spec(client_factory, obj, select_set=None): - """Builds the Object Spec object""" + """Builds the Object Spec object.""" obj_spec = client_factory.create('ns0:ObjectSpec') obj_spec.obj = obj obj_spec.skip = False @@ -187,7 +189,7 @@ def get_obj_spec(client_factory, obj, select_set=None): def get_prop_filter_spec(client_factory, obj_spec, prop_spec): - """Builds the Property Filter Spec Object""" + """Builds the Property Filter Spec Object.""" prop_filter_spec = \ client_factory.create('ns0:PropertyFilterSpec') prop_filter_spec.propSet = prop_spec @@ -195,10 +197,11 @@ def get_prop_filter_spec(client_factory, obj_spec, prop_spec): return prop_filter_spec -def get_properites_for_a_collection_of_objects(vim, type, +def get_properties_for_a_collection_of_objects(vim, type, obj_list, properties): - """Gets the list of properties for the collection of - objects of the type specified + """ + Gets the list of properties for the collection of + objects of the type specified. """ client_factory = vim.client.factory if len(obj_list) == 0: diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py index a46b4d10c..f2ef8d2d7 100644 --- a/nova/virt/vmwareapi/vm_util.py +++ b/nova/virt/vmwareapi/vm_util.py @@ -15,18 +15,19 @@ # License for the specific language governing permissions and limitations # under the License. """ -The VMware API VM utility module to build SOAP object specs +The VMware API VM utility module to build SOAP object specs. """ def build_datastore_path(datastore_name, path): - """Build the datastore compliant path""" + """Build the datastore compliant path.""" return "[%s] %s" % (datastore_name, path) def split_datastore_path(datastore_path): - """Split the VMWare style datastore path to get the Datastore - name and the entity path + """ + Split the VMWare style datastore path to get the Datastore + name and the entity path. """ spl = datastore_path.split('[', 1)[1].split(']', 1) path = "" @@ -40,7 +41,7 @@ def split_datastore_path(datastore_path): def get_vm_create_spec(client_factory, instance, data_store_name, network_name="vmnet0", os_type="otherGuest"): - """Builds the VM Create spec""" + """Builds the VM Create spec.""" config_spec = client_factory.create('ns0:VirtualMachineConfigSpec') config_spec.name = instance.name config_spec.guestId = os_type @@ -70,11 +71,12 @@ def get_vm_create_spec(client_factory, instance, data_store_name, def create_controller_spec(client_factory, key): - """Builds a Config Spec for the LSI Logic Controller's addition - which acts as the controller for the - Virtual Hard disk to be attached to the VM """ - #Create a controller for the Virtual Hard Disk + Builds a Config Spec for the LSI Logic Controller's addition + which acts as the controller for the virtual hard disk to be attached + to the VM. + """ + # Create a controller for the Virtual Hard Disk virtual_device_config = \ client_factory.create('ns0:VirtualDeviceConfigSpec') virtual_device_config.operation = "add" @@ -88,13 +90,15 @@ def create_controller_spec(client_factory, key): def create_network_spec(client_factory, network_name, mac_address): - """Builds a config spec for the addition of a new network - adapter to the VM""" + """ + Builds a config spec for the addition of a new network + adapter to the VM. + """ network_spec = \ client_factory.create('ns0:VirtualDeviceConfigSpec') network_spec.operation = "add" - #Get the recommended card type for the VM based on the guest OS of the VM + # Get the recommended card type for the VM based on the guest OS of the VM net_device = client_factory.create('ns0:VirtualPCNet32') backing = \ @@ -110,9 +114,9 @@ def create_network_spec(client_factory, network_name, mac_address): net_device.connectable = connectable_spec net_device.backing = backing - #The Server assigns a Key to the device. Here we pass a -ve temporary key. - #-ve because actual keys are +ve numbers and we don't - #want a clash with the key that server might associate with the device + # The Server assigns a Key to the device. Here we pass a -ve temporary key. + # -ve because actual keys are +ve numbers and we don't + # want a clash with the key that server might associate with the device net_device.key = -47 net_device.addressType = "manual" net_device.macAddress = mac_address @@ -124,14 +128,14 @@ def create_network_spec(client_factory, network_name, mac_address): def get_vmdk_attach_config_spec(client_factory, disksize, file_path, adapter_type="lsiLogic"): - """Builds the vmdk attach config spec""" + """Builds the vmdk attach config spec.""" config_spec = client_factory.create('ns0:VirtualMachineConfigSpec') - #The controller Key pertains to the Key of the LSI Logic Controller, which - #controls this Hard Disk + # The controller Key pertains to the Key of the LSI Logic Controller, which + # controls this Hard Disk device_config_spec = [] - #For IDE devices, there are these two default controllers created in the - #VM having keys 200 and 201 + # For IDE devices, there are these two default controllers created in the + # VM having keys 200 and 201 if adapter_type == "ide": controller_key = 200 else: @@ -149,7 +153,7 @@ def get_vmdk_attach_config_spec(client_factory, def get_vmdk_file_path_and_adapter_type(client_factory, hardware_devices): - """Gets the vmdk file path and the storage adapter type""" + """Gets the vmdk file path and the storage adapter type.""" if hardware_devices.__class__.__name__ == "ArrayOfVirtualDevice": hardware_devices = hardware_devices.VirtualDevice vmdk_file_path = None @@ -177,7 +181,7 @@ def get_vmdk_file_path_and_adapter_type(client_factory, hardware_devices): def get_copy_virtual_disk_spec(client_factory, adapter_type="lsilogic"): - """Builds the Virtual Disk copy spec""" + """Builds the Virtual Disk copy spec.""" dest_spec = client_factory.create('ns0:VirtualDiskSpec') dest_spec.adapterType = adapter_type dest_spec.diskType = "thick" @@ -185,7 +189,7 @@ def get_copy_virtual_disk_spec(client_factory, adapter_type="lsilogic"): def get_vmdk_create_spec(client_factory, size_in_kb, adapter_type="lsiLogic"): - """Builds the virtual disk create spec""" + """Builds the virtual disk create spec.""" create_vmdk_spec = \ client_factory.create('ns0:FileBackedVirtualDiskSpec') create_vmdk_spec.adapterType = adapter_type @@ -196,8 +200,10 @@ def get_vmdk_create_spec(client_factory, size_in_kb, adapter_type="lsiLogic"): def create_virtual_disk_spec(client_factory, disksize, controller_key, file_path=None): - """Creates a Spec for the addition/attaching of a - Virtual Disk to the VM""" + """ + Builds spec for the creation of a new/ attaching of an already existing + Virtual Disk to the VM. + """ virtual_device_config = \ client_factory.create('ns0:VirtualDeviceConfigSpec') virtual_device_config.operation = "add" @@ -223,9 +229,9 @@ def create_virtual_disk_spec(client_factory, virtual_disk.backing = disk_file_backing virtual_disk.connectable = connectable_spec - #The Server assigns a Key to the device. Here we pass a -ve temporary key. - #-ve because actual keys are +ve numbers and we don't - #want a clash with the key that server might associate with the device + # The Server assigns a Key to the device. Here we pass a -ve random key. + # -ve because actual keys are +ve numbers and we don't + # want a clash with the key that server might associate with the device virtual_disk.key = -100 virtual_disk.controllerKey = controller_key virtual_disk.unitNumber = 0 @@ -237,7 +243,7 @@ def create_virtual_disk_spec(client_factory, def get_dummy_vm_create_spec(client_factory, name, data_store_name): - """Builds the dummy VM create spec""" + """Builds the dummy VM create spec.""" config_spec = client_factory.create('ns0:VirtualMachineConfigSpec') config_spec.name = name @@ -269,7 +275,7 @@ def get_dummy_vm_create_spec(client_factory, name, data_store_name): def get_machine_id_change_spec(client_factory, mac, ip_addr, netmask, gateway): - """Builds the machine id change config spec""" + """Builds the machine id change config spec.""" machine_id_str = "%s;%s;%s;%s" % (mac, ip_addr, netmask, gateway) virtual_machine_config_spec = \ client_factory.create('ns0:VirtualMachineConfigSpec') @@ -283,12 +289,12 @@ def get_machine_id_change_spec(client_factory, mac, ip_addr, netmask, gateway): def get_add_vswitch_port_group_spec(client_factory, vswitch_name, port_group_name, vlan_id): - """Builds the virtual switch port group add spec""" + """Builds the virtual switch port group add spec.""" vswitch_port_group_spec = client_factory.create('ns0:HostPortGroupSpec') vswitch_port_group_spec.name = port_group_name vswitch_port_group_spec.vswitchName = vswitch_name - #VLAN ID of 0 means that VLAN tagging is not to be done for the network. + # VLAN ID of 0 means that VLAN tagging is not to be done for the network. vswitch_port_group_spec.vlanId = int(vlan_id) policy = client_factory.create('ns0:HostNetworkPolicy') diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index 2d87a627d..4b3c8adca 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -47,14 +47,14 @@ VMWARE_POWER_STATES = { class VMWareVMOps(object): - """ Management class for VM-related tasks """ + """Management class for VM-related tasks.""" def __init__(self, session): - """ Initializer """ + """Initializer.""" self._session = session def _wait_with_callback(self, instance_id, task, callback): - """ Waits for the task to finish and does a callback after """ + """Waits for the task to finish and does a callback after.""" ret = None try: ret = self._session._wait_for_task(instance_id, task) @@ -63,7 +63,7 @@ class VMWareVMOps(object): callback(ret) def list_instances(self): - """ Lists the VM instances that are registered with the ESX host """ + """Lists the VM instances that are registered with the ESX host.""" LOG.debug(_("Getting list of instances")) vms = self._session._call_method(vim_util, "get_objects", "VirtualMachine", @@ -96,7 +96,7 @@ class VMWareVMOps(object): the metadata .vmdk file. 4. Upload the disk file. 5. Attach the disk to the VM by reconfiguring the same. - 6. Power on the VM + 6. Power on the VM. """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref: @@ -122,7 +122,7 @@ class VMWareVMOps(object): _check_if_network_bridge_exists() def _get_datastore_ref(): - # Get the datastore list and choose the first local storage + """Get the datastore list and choose the first local storage.""" data_stores = self._session._call_method(vim_util, "get_objects", "Datastore", ["summary.type", "summary.name"]) for elem in data_stores: @@ -133,7 +133,7 @@ class VMWareVMOps(object): ds_type = prop.val elif prop.name == "summary.name": ds_name = prop.val - #Local storage identifier + # Local storage identifier if ds_type == "VMFS": data_store_name = ds_name return data_store_name @@ -146,8 +146,10 @@ class VMWareVMOps(object): data_store_name = _get_datastore_ref() def _get_image_properties(): - #Get the Size of the flat vmdk file that is there on the storage - #repository. + """ + Get the Size of the flat vmdk file that is there on the storage + repository. + """ image_size, image_properties = \ vmware_images.get_vmdk_size_and_properties( instance.image_id, instance) @@ -160,28 +162,29 @@ class VMWareVMOps(object): vmdk_file_size_in_kb, os_type, adapter_type = _get_image_properties() def _get_vmfolder_and_res_pool_mors(): - #Get the Vm folder ref from the datacenter + """Get the Vm folder ref from the datacenter.""" dc_objs = self._session._call_method(vim_util, "get_objects", "Datacenter", ["vmFolder"]) - #There is only one default datacenter in a standalone ESX host + # There is only one default datacenter in a standalone ESX host vm_folder_mor = dc_objs[0].propSet[0].val - #Get the resource pool. Taking the first resource pool coming our - #way. Assuming that is the default resource pool. + # Get the resource pool. Taking the first resource pool coming our + # way. Assuming that is the default resource pool. res_pool_mor = self._session._call_method(vim_util, "get_objects", "ResourcePool")[0].obj return vm_folder_mor, res_pool_mor vm_folder_mor, res_pool_mor = _get_vmfolder_and_res_pool_mors() - #Get the create vm config spec + # Get the create vm config spec config_spec = vm_util.get_vm_create_spec(client_factory, instance, data_store_name, net_name, os_type) def _execute_create_vm(): + """Create VM on ESX host.""" LOG.debug(_("Creating VM with the name %s on the ESX host") % instance.name) - #Create the VM on the ESX host + # Create the VM on the ESX host vm_create_task = self._session._call_method( self._session._get_vim(), "CreateVM_Task", vm_folder_mor, @@ -196,11 +199,11 @@ class VMWareVMOps(object): # Set the machine id for the VM for setting the IP self._set_machine_id(client_factory, instance) - #Naming the VM files in correspondence with the VM instance name + # Naming the VM files in correspondence with the VM instance name # The flat vmdk file name flat_uploaded_vmdk_name = "%s/%s-flat.vmdk" % (instance.name, instance.name) - #The vmdk meta-data file + # The vmdk meta-data file uploaded_vmdk_name = "%s/%s.vmdk" % (instance.name, instance.name) flat_uploaded_vmdk_path = vm_util.build_datastore_path(data_store_name, flat_uploaded_vmdk_name) @@ -208,12 +211,13 @@ class VMWareVMOps(object): uploaded_vmdk_name) def _create_virtual_disk(): - #Create a Virtual Disk of the size of the flat vmdk file. This is - #done just to generate the meta-data file whose specifics - #depend on the size of the disk, thin/thick provisioning and the - #storage adapter type. - #Here we assume thick provisioning and lsiLogic for the adapter - #type + """Create a virtual disk of the size of flat vmdk file.""" + # Create a Virtual Disk of the size of the flat vmdk file. This is + # done just to generate the meta-data file whose specifics + # depend on the size of the disk, thin/thick provisioning and the + # storage adapter type. + # Here we assume thick provisioning and lsiLogic for the adapter + # type LOG.debug(_("Creating Virtual Disk of size " "%(vmdk_file_size_in_kb)s KB and adapter type " "%(adapter_type)s on the ESX host local store" @@ -245,7 +249,7 @@ class VMWareVMOps(object): "store %(data_store_name)s") % {"flat_uploaded_vmdk_path": flat_uploaded_vmdk_path, "data_store_name": data_store_name}) - #Delete the -flat.vmdk file created. .vmdk file is retained. + # Delete the -flat.vmdk file created. .vmdk file is retained. vmdk_delete_task = self._session._call_method( self._session._get_vim(), "DeleteDatastoreFile_Task", @@ -262,12 +266,13 @@ class VMWareVMOps(object): cookies = self._session._get_vim().client.options.transport.cookiejar def _fetch_image_on_esx_datastore(): + """Fetch image from Glance to ESX datastore.""" LOG.debug(_("Downloading image file data %(image_id)s to the ESX " "data store %(data_store_name)s") % ({'image_id': instance.image_id, 'data_store_name': data_store_name})) - #Upload the -flat.vmdk file whose meta-data file we just created - #above + # Upload the -flat.vmdk file whose meta-data file we just created + # above vmware_images.fetch_image( instance.image_id, instance, @@ -285,8 +290,10 @@ class VMWareVMOps(object): vm_ref = self._get_vm_ref_from_the_name(instance.name) def _attach_vmdk_to_the_vm(): - #Attach the vmdk uploaded to the VM. VM reconfigure is done - #to do so. + """ + Attach the vmdk uploaded to the VM. VM reconfigure is done + to do so. + """ vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_spec( client_factory, vmdk_file_size_in_kb, uploaded_vmdk_path, @@ -304,8 +311,9 @@ class VMWareVMOps(object): _attach_vmdk_to_the_vm() def _power_on_vm(): + """Power on the VM.""" LOG.debug(_("Powering on the VM instance %s") % instance.name) - #Power On the VM + # Power On the VM power_on_task = self._session._call_method( self._session._get_vim(), "PowerOnVM_Task", vm_ref) @@ -325,7 +333,7 @@ class VMWareVMOps(object): 3. Call CopyVirtualDisk which coalesces the disk chain to form a single vmdk, rather a .vmdk metadata file and a -flat.vmdk disk data file. 4. Now upload the -flat.vmdk file to the image store. - 5. Delete the coalesced .vmdk and -flat.vmdk created + 5. Delete the coalesced .vmdk and -flat.vmdk created. """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: @@ -336,7 +344,7 @@ class VMWareVMOps(object): service_content = self._session._get_vim().get_service_content() def _get_vm_and_vmdk_attribs(): - #Get the vmdk file name that the VM is pointing to + # Get the vmdk file name that the VM is pointing to hardware_devices = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "config.hardware.device") @@ -355,7 +363,7 @@ class VMWareVMOps(object): os_type = _get_vm_and_vmdk_attribs() def _create_vm_snapshot(): - #Create a snapshot of the VM + # Create a snapshot of the VM LOG.debug(_("Creating Snapshot of the VM instance %s ") % instance.name) snapshot_task = self._session._call_method( @@ -372,8 +380,8 @@ class VMWareVMOps(object): _create_vm_snapshot() def _check_if_tmp_folder_exists(): - #Copy the contents of the VM that were there just before the - #snapshot was taken + # Copy the contents of the VM that were there just before the + # snapshot was taken ds_ref_ret = vim_util.get_dynamic_property( self._session._get_vim(), vm_ref, @@ -388,7 +396,7 @@ class VMWareVMOps(object): ds_ref, "Datastore", "browser") - #Check if the vmware-tmp folder exists or not. If not, create one + # Check if the vmware-tmp folder exists or not. If not, create one tmp_folder_path = vm_util.build_datastore_path(datastore_name, "vmware-tmp") if not self._path_exists(ds_browser, tmp_folder_path): @@ -397,17 +405,17 @@ class VMWareVMOps(object): _check_if_tmp_folder_exists() - #Generate a random vmdk file name to which the coalesced vmdk content - #will be copied to. A random name is chosen so that we don't have - #name clashes. + # Generate a random vmdk file name to which the coalesced vmdk content + # will be copied to. A random name is chosen so that we don't have + # name clashes. random_name = str(uuid.uuid4()) dest_vmdk_file_location = vm_util.build_datastore_path(datastore_name, "vmware-tmp/%s.vmdk" % random_name) dc_ref = self._get_datacenter_name_and_ref()[0] def _copy_vmdk_content(): - #Copy the contents of the disk ( or disks, if there were snapshots - #done earlier) to a temporary vmdk file. + # Copy the contents of the disk ( or disks, if there were snapshots + # done earlier) to a temporary vmdk file. copy_spec = vm_util.get_copy_virtual_disk_spec(client_factory, adapter_type) LOG.debug(_("Copying disk data before snapshot of the VM " @@ -431,7 +439,7 @@ class VMWareVMOps(object): cookies = self._session._get_vim().client.options.transport.cookiejar def _upload_vmdk_to_image_repository(): - #Upload the contents of -flat.vmdk file which has the disk data. + # Upload the contents of -flat.vmdk file which has the disk data. LOG.debug(_("Uploading image %s") % snapshot_name) vmware_images.upload_image( snapshot_name, @@ -449,7 +457,11 @@ class VMWareVMOps(object): _upload_vmdk_to_image_repository() def _clean_temp_data(): - #Delete the temporary vmdk created above. + """ + Delete temporary vmdk files generated in image handling + operations. + """ + # Delete the temporary vmdk created above. LOG.debug(_("Deleting temporary vmdk file %s") % dest_vmdk_file_location) remove_disk_task = self._session._call_method( @@ -465,7 +477,7 @@ class VMWareVMOps(object): _clean_temp_data() def reboot(self, instance): - """ Reboot a VM instance """ + """Reboot a VM instance.""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise exception.NotFound(_("instance - %s not present") % @@ -483,13 +495,13 @@ class VMWareVMOps(object): elif prop.name == "summary.guest.toolsStatus": tools_status = prop.val - #Raise an exception if the VM is not powered On. + # Raise an exception if the VM is not powered On. if pwr_state not in ["poweredOn"]: raise exception.Invalid(_("instance - %s not poweredOn. So can't " "be rebooted.") % instance.name) - #If vmware tools are installed in the VM, then do a guest reboot. - #Otherwise do a hard reset. + # If vmware tools are installed in the VM, then do a guest reboot. + # Otherwise do a hard reset. if tools_status not in ['toolsNotInstalled', 'toolsNotRunning']: LOG.debug(_("Rebooting guest OS of VM %s") % instance.name) self._session._call_method(self._session._get_vim(), "RebootGuest", @@ -507,7 +519,7 @@ class VMWareVMOps(object): Destroy a VM instance. Steps followed are: 1. Power off the VM, if it is in poweredOn state. 2. Un-register a VM. - 3. Delete the contents of the folder holding the VM related data + 3. Delete the contents of the folder holding the VM related data. """ try: vm_ref = self._get_vm_ref_from_the_name(instance.name) @@ -529,7 +541,7 @@ class VMWareVMOps(object): if vm_config_pathname: datastore_name, vmx_file_path = \ vm_util.split_datastore_path(vm_config_pathname) - #Power off the VM if it is in PoweredOn state. + # Power off the VM if it is in PoweredOn state. if pwr_state == "poweredOn": LOG.debug(_("Powering off the VM %s") % instance.name) poweroff_task = self._session._call_method( @@ -538,7 +550,7 @@ class VMWareVMOps(object): self._session._wait_for_task(instance.id, poweroff_task) LOG.debug(_("Powered off the VM %s") % instance.name) - #Un-register the VM + # Un-register the VM try: LOG.debug(_("Unregistering the VM %s") % instance.name) self._session._call_method(self._session._get_vim(), @@ -548,7 +560,8 @@ class VMWareVMOps(object): LOG.warn(_("In vmwareapi:vmops:destroy, got this exception" " while un-registering the VM: %s") % str(excep)) - #Delete the folder holding the VM related content on the datastore. + # Delete the folder holding the VM related content on + # the datastore. try: dir_ds_compliant_path = vm_util.build_datastore_path( datastore_name, @@ -564,7 +577,7 @@ class VMWareVMOps(object): name=dir_ds_compliant_path) self._session._wait_for_task(instance.id, delete_task) LOG.debug(_("Deleted contents of the VM %(name)s from " - "datastore %(datastore_name)s") + "datastore %(datastore_name)s") % ({'name': instance.name, 'datastore_name': datastore_name})) except Exception, excep: @@ -576,15 +589,15 @@ class VMWareVMOps(object): LOG.exception(e) def pause(self, instance, callback): - """ Pause a VM instance """ + """Pause a VM instance.""" raise exception.APIError("pause not supported for vmwareapi") def unpause(self, instance, callback): - """ Un-Pause a VM instance """ + """Un-Pause a VM instance.""" raise exception.APIError("unpause not supported for vmwareapi") def suspend(self, instance, callback): - """ Suspend the specified instance """ + """Suspend the specified instance.""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise exception.NotFound(_("instance - %s not present") % @@ -593,14 +606,14 @@ class VMWareVMOps(object): pwr_state = self._session._call_method(vim_util, "get_dynamic_property", vm_ref, "VirtualMachine", "runtime.powerState") - #Only PoweredOn VMs can be suspended. + # Only PoweredOn VMs can be suspended. if pwr_state == "poweredOn": LOG.debug(_("Suspending the VM %s ") % instance.name) suspend_task = self._session._call_method(self._session._get_vim(), "SuspendVM_Task", vm_ref) self._wait_with_callback(instance.id, suspend_task, callback) LOG.debug(_("Suspended the VM %s ") % instance.name) - #Raise Exception if VM is poweredOff + # Raise Exception if VM is poweredOff elif pwr_state == "poweredOff": raise exception.Invalid(_("instance - %s is poweredOff and hence " " can't be suspended.") % instance.name) @@ -608,7 +621,7 @@ class VMWareVMOps(object): "without doing anything") % instance.name) def resume(self, instance, callback): - """ Resume the specified instance """ + """Resume the specified instance.""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise exception.NotFound(_("instance - %s not present") % @@ -629,7 +642,7 @@ class VMWareVMOps(object): "and hence can't be Resumed.") % instance.name) def get_info(self, instance_name): - """ Return data about the VM instance """ + """Return data about the VM instance.""" vm_ref = self._get_vm_ref_from_the_name(instance_name) if vm_ref is None: raise exception.NotFound(_("instance - %s not present") % @@ -661,12 +674,12 @@ class VMWareVMOps(object): 'cpu_time': 0} def get_diagnostics(self, instance): - """ Return data about VM diagnostics """ + """Return data about VM diagnostics.""" raise exception.APIError("get_diagnostics not implemented for " "vmwareapi") def get_console_output(self, instance): - """ Return snapshot of console """ + """Return snapshot of console.""" vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise exception.NotFound(_("instance - %s not present") % @@ -688,12 +701,14 @@ class VMWareVMOps(object): return "" def get_ajax_console(self, instance): - """ Return link to instance's ajax console """ + """Return link to instance's ajax console.""" return 'http://fakeajaxconsole/fake_url' def _set_machine_id(self, client_factory, instance): - """ Set the machine id of the VM for guest tools to pick up and change - the IP """ + """ + Set the machine id of the VM for guest tools to pick up and change + the IP. + """ vm_ref = self._get_vm_ref_from_the_name(instance.name) if vm_ref is None: raise exception.NotFound(_("instance - %s not present") % @@ -722,19 +737,19 @@ class VMWareVMOps(object): 'ip_addr': ip_addr})) def _get_datacenter_name_and_ref(self): - """ Get the datacenter name and the reference. """ + """Get the datacenter name and the reference.""" dc_obj = self._session._call_method(vim_util, "get_objects", "Datacenter", ["name"]) return dc_obj[0].obj, dc_obj[0].propSet[0].val def _path_exists(self, ds_browser, ds_path): - """Check if the path exists on the datastore""" + """Check if the path exists on the datastore.""" search_task = self._session._call_method(self._session._get_vim(), "SearchDatastore_Task", ds_browser, datastorePath=ds_path) - #Wait till the state changes from queued or running. - #If an error state is returned, it means that the path doesn't exist. + # Wait till the state changes from queued or running. + # If an error state is returned, it means that the path doesn't exist. while True: task_info = self._session._call_method(vim_util, "get_dynamic_property", @@ -748,9 +763,11 @@ class VMWareVMOps(object): return True def _mkdir(self, ds_path): - """ Creates a directory at the path specified. If it is just "NAME", - then a directory with this name is formed at the topmost level of the - DataStore. """ + """ + Creates a directory at the path specified. If it is just "NAME", + then a directory with this name is created at the topmost level of the + DataStore. + """ LOG.debug(_("Creating directory with path %s") % ds_path) self._session._call_method(self._session._get_vim(), "MakeDirectory", self._session._get_vim().get_service_content().fileManager, @@ -758,7 +775,7 @@ class VMWareVMOps(object): LOG.debug(_("Created directory with path %s") % ds_path) def _get_vm_ref_from_the_name(self, vm_name): - """ Get reference to the VM with the name specified. """ + """Get reference to the VM with the name specified.""" vms = self._session._call_method(vim_util, "get_objects", "VirtualMachine", ["name"]) for vm in vms: diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py index 2b389987e..d9c7f52e5 100644 --- a/nova/virt/vmwareapi/vmware_images.py +++ b/nova/virt/vmwareapi/vmware_images.py @@ -15,15 +15,14 @@ # License for the specific language governing permissions and limitations # under the License. """ -Utility functions for Image transfer +Utility functions for Image transfer. """ -import time +import glance.client from nova import exception from nova import flags from nova import log as logging -from nova.virt.vmwareapi import io_util from nova.virt.vmwareapi import read_write_util FLAGS = flags.FLAGS @@ -35,44 +34,9 @@ WRITE_CHUNKSIZE = 2 * 1024 * 1024 LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images") -def start_transfer(read_file_handle, write_file_handle, data_size): - """ Start the data transfer from the read handle to the write handle. """ - - #The thread safe pipe - thread_safe_pipe = io_util.ThreadSafePipe(QUEUE_BUFFER_SIZE) - #The read thread - read_thread = io_util.IOThread(read_file_handle, thread_safe_pipe, - READ_CHUNKSIZE, long(data_size)) - #The write thread - write_thread = io_util.IOThread(thread_safe_pipe, write_file_handle, - WRITE_CHUNKSIZE, long(data_size)) - read_thread.start() - write_thread.start() - LOG.debug(_("Starting image file transfer")) - #Wait till both the read thread and the write thread are done - while not (read_thread.is_done() and write_thread.is_done()): - if read_thread.get_error() or write_thread.get_error(): - read_thread.stop_io_transfer() - write_thread.stop_io_transfer() - # If there was an exception in reading or writing, raise the same. - read_excep = read_thread.get_exception() - write_excep = write_thread.get_exception() - if read_excep is not None: - LOG.exception(str(read_excep)) - raise exception.Error(read_excep) - if write_excep is not None: - LOG.exception(str(write_excep)) - raise exception.Error(write_excep) - time.sleep(2) - LOG.debug(_("Finished image file transfer and closing the file handles")) - #Close the file handles - read_file_handle.close() - write_file_handle.close() - - def fetch_image(image, instance, **kwargs): - """ Fetch an image for attaching to the newly created VM """ - #Depending upon the image service, make appropriate image service call + """Fetch an image for attaching to the newly created VM.""" + # Depending upon the image service, make appropriate image service call if FLAGS.image_service == "nova.image.glance.GlanceImageService": func = _get_glance_image elif FLAGS.image_service == "nova.image.s3.S3ImageService": @@ -86,8 +50,8 @@ def fetch_image(image, instance, **kwargs): def upload_image(image, instance, **kwargs): - """ Upload the newly snapshotted VM disk file. """ - #Depending upon the image service, make appropriate image service call + """Upload the newly snapshotted VM disk file.""" + # Depending upon the image service, make appropriate image service call if FLAGS.image_service == "nova.image.glance.GlanceImageService": func = _put_glance_image elif FLAGS.image_service == "nova.image.s3.S3ImageService": @@ -101,12 +65,11 @@ def upload_image(image, instance, **kwargs): def _get_glance_image(image, instance, **kwargs): - """ Download image from the glance image server. """ + """Download image from the glance image server.""" LOG.debug(_("Downloading image %s from glance image server") % image) - read_file_handle = read_write_util.GlanceHTTPReadFile(FLAGS.glance_host, - FLAGS.glance_port, - image) - file_size = read_file_handle.get_size() + glance_client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) + metadata, read_file_handle = glance_client.get_image(image) + file_size = int(metadata['size']) write_file_handle = read_write_util.VMWareHTTPWriteFile( kwargs.get("host"), kwargs.get("data_center_name"), @@ -114,22 +77,23 @@ def _get_glance_image(image, instance, **kwargs): kwargs.get("cookies"), kwargs.get("file_path"), file_size) - start_transfer(read_file_handle, write_file_handle, file_size) + for chunk in read_file_handle: + write_file_handle.write(chunk) LOG.debug(_("Downloaded image %s from glance image server") % image) def _get_s3_image(image, instance, **kwargs): - """ Download image from the S3 image server. """ + """Download image from the S3 image server.""" raise NotImplementedError def _get_local_image(image, instance, **kwargs): - """ Download image from the local nova compute node. """ + """Download image from the local nova compute node.""" raise NotImplementedError def _put_glance_image(image, instance, **kwargs): - """ Upload the snapshotted vm disk file to Glance image server """ + """Upload the snapshotted vm disk file to Glance image server.""" LOG.debug(_("Uploading image %s to the Glance image server") % image) read_file_handle = read_write_util.VmWareHTTPReadFile( kwargs.get("host"), @@ -137,47 +101,48 @@ def _put_glance_image(image, instance, **kwargs): kwargs.get("datastore_name"), kwargs.get("cookies"), kwargs.get("file_path")) - file_size = read_file_handle.get_size() - write_file_handle = read_write_util.GlanceHTTPWriteFile( - FLAGS.glance_host, - FLAGS.glance_port, - image, - file_size, - kwargs.get("os_type"), - kwargs.get("adapter_type"), - kwargs.get("image_version")) - start_transfer(read_file_handle, write_file_handle, file_size) + glance_client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) + image_metadata = {"is_public": True, + "disk_format": "vmdk", + "container_format": "bare", + "type": "vmdk", + "properties": {"vmware_adaptertype": + kwargs.get("adapter_type"), + "vmware_ostype": kwargs.get("os_type"), + "vmware_image_version": + kwargs.get("image_version")}} + glance_client.update_image(image, image_meta=image_metadata, + image_data=read_file_handle) LOG.debug(_("Uploaded image %s to the Glance image server") % image) def _put_local_image(image, instance, **kwargs): - """ Upload the snapshotted vm disk file to the local nova compute node. """ + """Upload the snapshotted vm disk file to the local nova compute node.""" raise NotImplementedError def _put_s3_image(image, instance, **kwargs): - """ Upload the snapshotted vm disk file to S3 image server. """ + """Upload the snapshotted vm disk file to S3 image server.""" raise NotImplementedError def get_vmdk_size_and_properties(image, instance): - """ Get size of the vmdk file that is to be downloaded for attach in spawn. + """ + Get size of the vmdk file that is to be downloaded for attach in spawn. Need this to create the dummy virtual disk for the meta-data file. The - geometry of the disk created depends on the size.""" + geometry of the disk created depends on the size. + """ LOG.debug(_("Getting image size for the image %s") % image) if FLAGS.image_service == "nova.image.glance.GlanceImageService": - read_file_handle = read_write_util.GlanceHTTPReadFile( - FLAGS.glance_host, - FLAGS.glance_port, - image) + glance_client = glance.client.Client(FLAGS.glance_host, + FLAGS.glance_port) + meta_data = glance_client.get_image_meta(image) + size, properties = meta_data["size"], meta_data["properties"] elif FLAGS.image_service == "nova.image.s3.S3ImageService": raise NotImplementedError elif FLAGS.image_service == "nova.image.local.LocalImageService": raise NotImplementedError - size = read_file_handle.get_size() - properties = read_file_handle.get_image_properties() - read_file_handle.close() LOG.debug(_("Got image size of %(size)s for the image %(image)s") % locals()) return size, properties diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index 92cd83ed1..bb10c6043 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -29,6 +29,7 @@ A connection to the VMware ESX platform. :vmwareapi_api_retry_count: The API retry count in case of failure such as network failures (socket errors etc.) (default: 10). + """ import time @@ -78,7 +79,7 @@ TIME_BETWEEN_API_CALL_RETRIES = 2.0 class Failure(Exception): - """Base Exception class for handling task failures""" + """Base Exception class for handling task failures.""" def __init__(self, details): self.details = details @@ -103,7 +104,7 @@ def get_connection(_): class VMWareESXConnection(object): - """The ESX host connection object""" + """The ESX host connection object.""" def __init__(self, host_ip, host_username, host_password, api_retry_count, scheme="https"): @@ -112,80 +113,85 @@ class VMWareESXConnection(object): self._vmops = VMWareVMOps(session) def init_host(self, host): - """Do the initialization that needs to be done""" - #FIXME(sateesh): implement this + """Do the initialization that needs to be done.""" + # FIXME(sateesh): implement this pass def list_instances(self): - """List VM instances""" + """List VM instances.""" return self._vmops.list_instances() def spawn(self, instance): - """Create VM instance""" + """Create VM instance.""" self._vmops.spawn(instance) def snapshot(self, instance, name): - """Create snapshot from a running VM instance""" + """Create snapshot from a running VM instance.""" self._vmops.snapshot(instance, name) def reboot(self, instance): - """Reboot VM instance""" + """Reboot VM instance.""" self._vmops.reboot(instance) def destroy(self, instance): - """Destroy VM instance""" + """Destroy VM instance.""" self._vmops.destroy(instance) def pause(self, instance, callback): - """Pause VM instance""" + """Pause VM instance.""" self._vmops.pause(instance, callback) def unpause(self, instance, callback): - """Unpause paused VM instance""" + """Unpause paused VM instance.""" self._vmops.unpause(instance, callback) def suspend(self, instance, callback): - """Suspend the specified instance""" + """Suspend the specified instance.""" self._vmops.suspend(instance, callback) def resume(self, instance, callback): - """Resume the suspended VM instance""" + """Resume the suspended VM instance.""" self._vmops.resume(instance, callback) def get_info(self, instance_id): - """Return info about the VM instance""" + """Return info about the VM instance.""" return self._vmops.get_info(instance_id) def get_diagnostics(self, instance): - """Return data about VM diagnostics""" + """Return data about VM diagnostics.""" return self._vmops.get_info(instance) def get_console_output(self, instance): - """Return snapshot of console""" + """Return snapshot of console.""" return self._vmops.get_console_output(instance) def get_ajax_console(self, instance): - """Return link to instance's ajax console""" + """Return link to instance's ajax console.""" return self._vmops.get_ajax_console(instance) def attach_volume(self, instance_name, device_path, mountpoint): - """Attach volume storage to VM instance""" + """Attach volume storage to VM instance.""" pass def detach_volume(self, instance_name, mountpoint): - """Detach volume storage to VM instance""" + """Detach volume storage to VM instance.""" pass def get_console_pool_info(self, console_type): - """Get info about the host on which the VM resides""" + """Get info about the host on which the VM resides.""" return {'address': FLAGS.vmwareapi_host_ip, 'username': FLAGS.vmwareapi_host_username, 'password': FLAGS.vmwareapi_host_password} + def update_available_resource(self, ctxt, host): + """This method is supported only by libvirt.""" + return + class VMWareAPISession(object): - """Sets up a session with the ESX host and handles all - the calls made to the host + """ + Sets up a session with the ESX host and handles all + the calls made to the host. """ def __init__(self, host_ip, host_username, host_password, @@ -200,11 +206,11 @@ class VMWareAPISession(object): self._create_session() def _get_vim_object(self): - """Create the VIM Object instance""" + """Create the VIM Object instance.""" return vim.Vim(protocol=self._scheme, host=self._host_ip) def _create_session(self): - """Creates a session with the ESX host""" + """Creates a session with the ESX host.""" while True: try: # Login and setup the session with the ESX host for making @@ -241,12 +247,13 @@ class VMWareAPISession(object): pass def _is_vim_object(self, module): - """Check if the module is a VIM Object instance""" + """Check if the module is a VIM Object instance.""" return isinstance(module, vim.Vim) def _call_method(self, module, method, *args, **kwargs): - """Calls a method within the module specified with - args provided + """ + Calls a method within the module specified with + args provided. """ args = list(args) retry_count = 0 @@ -254,7 +261,8 @@ class VMWareAPISession(object): while True: try: if not self._is_vim_object(module): - #If it is not the first try, then get the latest vim object + # If it is not the first try, then get the latest + # vim object if retry_count > 0: args = args[1:] args = [self.vim] + args @@ -264,8 +272,7 @@ class VMWareAPISession(object): for method_elem in method.split("."): temp_module = getattr(temp_module, method_elem) - ret_val = temp_module(*args, **kwargs) - return ret_val + return temp_module(*args, **kwargs) except error_util.VimFaultException, excep: # If it is a Session Fault Exception, it may point # to a session gone bad. So we try re-creating a session @@ -274,9 +281,9 @@ class VMWareAPISession(object): if error_util.FAULT_NOT_AUTHENTICATED in excep.fault_list: self._create_session() else: - #No re-trying for errors for API call has gone through - #and is the caller's fault. Caller should handle these - #errors. e.g, InvalidArgument fault. + # No re-trying for errors for API call has gone through + # and is the caller's fault. Caller should handle these + # errors. e.g, InvalidArgument fault. break except error_util.SessionOverLoadException, excep: # For exceptions which may come because of session overload, @@ -299,13 +306,14 @@ class VMWareAPISession(object): raise def _get_vim(self): - """Gets the VIM object reference""" + """Gets the VIM object reference.""" if self.vim is None: self._create_session() return self.vim def _wait_for_task(self, instance_id, task_ref): - """Return a Deferred that will give the result of the given task. + """ + Return a Deferred that will give the result of the given task. The task is polled until it completes. """ done = event.Event() @@ -317,7 +325,8 @@ class VMWareAPISession(object): return ret_val def _poll_task(self, instance_id, task_ref, done): - """Poll the given task, and fires the given Deferred if we + """ + Poll the given task, and fires the given Deferred if we get a result. """ try: @@ -331,7 +340,7 @@ class VMWareAPISession(object): if task_info.state in ['queued', 'running']: return elif task_info.state == 'success': - LOG.info(_("Task [%(task_name)s] %(task_ref)s " + LOG.debug(_("Task [%(task_name)s] %(task_ref)s " "status: success") % locals()) done.send("success") else: -- cgit From f5ad4125d00396a7a3a334eb347aeeb47d8d4989 Mon Sep 17 00:00:00 2001 From: sateesh Date: Wed, 16 Mar 2011 22:01:41 +0530 Subject: Removing io_util.py. We now use eventlets library instead. --- nova/virt/vmwareapi/io_util.py | 149 ----------------------------------------- 1 file changed, 149 deletions(-) delete mode 100644 nova/virt/vmwareapi/io_util.py (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py deleted file mode 100644 index edec3eb34..000000000 --- a/nova/virt/vmwareapi/io_util.py +++ /dev/null @@ -1,149 +0,0 @@ -# vim: tabstop=4 shiftwidth=4 softtabstop=4 - -# Copyright (c) 2011 Citrix Systems, Inc. -# Copyright 2011 OpenStack LLC. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -""" -Reads a chunk from input file and writes the same to the output file till -it reaches the transferable size -""" - -from Queue import Empty -from Queue import Full -from Queue import Queue -from threading import Thread -import time -import traceback - -THREAD_SLEEP_TIME = 0.01 - - -class ThreadSafePipe(Queue): - """ThreadSafePipe class queues the chunk data""" - - def __init__(self, max_size=None): - Queue.__init__(self, max_size) - self.eof = False - - def write(self, data): - """Writes the chunk data to the queue""" - self.put(data, block=False) - - def read(self): - """Retrieves the chunk data from the queue""" - return self.get(block=False) - - def set_eof(self, eof): - """Sets EOF to mark reading of input file finishes""" - self.eof = eof - - def get_eof(self): - """Returns whether EOF reached.""" - return self.eof - - -class IOThread(Thread): - """IOThread reads chunks from input file and pipes it to output file till - it reaches the transferable size - """ - - def __init__(self, input_file, output_file, chunk_size, transfer_size): - Thread.__init__(self) - self.input_file = input_file - self.output_file = output_file - self.chunk_size = chunk_size - self.transfer_size = transfer_size - self.read_size = 0 - self._done = False - self._stop_transfer = False - self._error = False - self._exception = None - - def run(self): - """Pipes the input chunk read to the output file till it reaches - a transferable size - """ - try: - if self.transfer_size and self.transfer_size <= self.chunk_size: - self.chunk_size = self.transfer_size - data = None - while True: - if not self.transfer_size is None: - if self.read_size >= self.transfer_size: - break - if self._stop_transfer: - break - try: - #read chunk only if no previous chunk - if data is None: - if isinstance(self.input_file, ThreadSafePipe): - data = self.input_file.read() - else: - data = self.input_file.read(self.chunk_size) - if not data: - # no more data to read - break - if data: - # write chunk - self.output_file.write(data) - self.read_size = self.read_size + len(data) - # clear chunk since write is a success - data = None - except Empty: - # Pipe side is empty - safe to check for eof signal - if self.input_file.get_eof(): - # no more data in read - break - #Restrict tight loop - time.sleep(THREAD_SLEEP_TIME) - except Full: - # Pipe full while writing to pipe - safe to retry since - #chunk is preserved - #Restrict tight loop - time.sleep(THREAD_SLEEP_TIME) - if isinstance(self.output_file, ThreadSafePipe): - # If this is the reader thread, send eof signal - self.output_file.set_eof(True) - - if not self.transfer_size is None: - if self.read_size < self.transfer_size: - raise IOError(_("Not enough data (%(read_size)d " - "of %(transfer_size)d bytes)") \ - % ({'read_size': self.read_size, - 'transfer_size': self.transfer_size})) - - except Exception: - self._error = True - self._exception = str(traceback.format_exc()) - self._done = True - - def stop_io_transfer(self): - """Set the stop flag to true, which causes the thread to stop - safely - """ - self._stop_transfer = True - self.join() - - def get_error(self): - """Returns the error string""" - return self._error - - def get_exception(self): - """Returns the traceback exception string""" - return self._exception - - def is_done(self): - """Checks whether transfer is complete""" - return self._done -- cgit From 9cb503ae9d4112fa464f2284631ad1e24f8f7ce4 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 11:38:40 -0500 Subject: Stuff --- nova/virt/xenapi/vmops.py | 3 +-- nova/virt/xenapi_conn.py | 6 +----- 2 files changed, 2 insertions(+), 7 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index cdc4a417c..ebaa4a69a 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -363,8 +363,7 @@ class VMOps(object): def resize_instance(self, instance, vdi_uuid): """Resize a running instance by changing it's RAM and disk size """ vm_ref = VMHelper.lookup(self._session, instance.name) - vdi_ref, vm_vdi_rec = \ - VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) + vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) new_disk_size = instance.local_gb #TODO(mdietz): this will need to be adjusted for swap later diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 6b1b51fee..b8256d205 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -164,15 +164,11 @@ class XenAPIConnection(object): """Create VM instance""" self._vmops.spawn(instance) - def resize_instance(self, instance, disk_info): - """Resizes instance attributes such as RAM and disk space to the - attributes specified by the record""" - self._vmops.resize_instance(instance, disk_info['cow']) - def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" vdi_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], disk_info['cow']) + self._vmops.resize_instance(instance, vdi_uuid) self._vmops._spawn_with_disk(instance, vdi_uuid) def snapshot(self, instance, image_id): -- cgit From dee86f53b0d1dccbc69d354b66ca7a4767e81d43 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 11:54:10 -0500 Subject: tweak --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ebaa4a69a..483b0cb82 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -364,7 +364,7 @@ class VMOps(object): """Resize a running instance by changing it's RAM and disk size """ vm_ref = VMHelper.lookup(self._session, instance.name) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - new_disk_size = instance.local_gb + new_disk_size = instance.local_gb * 1024 #TODO(mdietz): this will need to be adjusted for swap later task = self._session.call_xenapi('VDI.resize_online', vdi_ref, -- cgit From d99a8d48cf38eb6be01587f9b377f48ff6cd88a2 Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Wed, 16 Mar 2011 17:09:13 +0000 Subject: Logging statements --- nova/virt/xenapi/vmops.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 483b0cb82..c292822ca 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -363,13 +363,16 @@ class VMOps(object): def resize_instance(self, instance, vdi_uuid): """Resize a running instance by changing it's RAM and disk size """ vm_ref = VMHelper.lookup(self._session, instance.name) - vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) new_disk_size = instance.local_gb * 1024 + LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %d megs") % (vdi_uuid, + instance.name, new_disk_size)) + vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) #TODO(mdietz): this will need to be adjusted for swap later task = self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) self._session.wait_for_task(task, instance.id) + LOG.debug(_("Resize instance %s complete") % (instance.name)) def reboot(self, instance): """Reboot VM instance""" -- cgit From 5379f3654e04a0443f3237623f772a17f13e9d90 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Wed, 16 Mar 2011 12:44:38 -0500 Subject: refactored, bugfixes --- nova/virt/xenapi/vm_utils.py | 4 +- nova/virt/xenapi/vmops.py | 163 +++++++++++++++++++------------------------ 2 files changed, 72 insertions(+), 95 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index f07b57796..1f03b4124 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -234,11 +234,11 @@ class VMHelper(HelperBase): raise StorageError(_('Unable to destroy VBD %s') % vbd_ref) @classmethod - def create_vif(cls, session, vm_ref, network_ref, mac_address, dev="0"): + def create_vif(cls, session, vm_ref, network_ref, mac_address, dev): """Create a VIF record. Returns a Deferred that gives the new VIF reference.""" vif_rec = {} - vif_rec['device'] = dev + vif_rec['device'] = str(dev) vif_rec['network'] = network_ref vif_rec['VM'] = vm_ref vif_rec['MAC'] = mac_address diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 64f2c6231..485dd41ca 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -128,13 +128,17 @@ class VMOps(object): vdi_ref=vdi_ref, userdevice=0, bootable=True) # inject_network_info and create vifs - if network_info is not None: - self.inject_network_info(instance, network_info) - self.create_vifs(instance, [nw for (nw, mapping) in network_info]) - else: - # TODO(tr3buchet) - goes away with multi-nic - networks = self.inject_network_info(instance) - self.create_vifs(instance, networks) + # TODO(tr3buchet) - check to make sure we have network info, otherwise + # create it now. This goes away once nova-multi-nic hits. + if network_info is None: + admin_context = context.get_admin_context() + IPs = db.fixed_ip_get_all_by_instance(admin_context, + instance['id']) + networks = db.network_get_all_by_instance(admin_context, + instance['id']) + network_info = self._get_network_info(instance, networks, IPs) + self.inject_network_info(vm_ref, network_info) + self.create_vifs(vm_ref, network_info) LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) @@ -689,104 +693,77 @@ class VMOps(object): # TODO: implement this! return 'http://fakeajaxconsole/fake_url' - def inject_network_info(self, instance, network_info=None): + # TODO(tr3buchet) - remove this function after nova multi-nic + def _get_network_info(self, instance, networks, IPs): + """creates network info list for instance""" + + tuple_list = [] + for network in networks: + network_IPs = [ip for ip in IPs if ip.network_id == network.id] + + def ip_dict(ip): + return { + "ip": ip.address, + "netmask": network["netmask"], + "enabled": "1"} + + def ip6_dict(ip6): + return { + "ip": ip6.addressV6, + "netmask": ip6.netmaskV6, + "gateway": ip6.gatewayV6, + "enabled": "1"} + + mac_id = instance.mac_address.replace(':', '') + location = 'vm-data/networking/%s' % mac_id + info = { + 'label': network['label'], + 'gateway': network['gateway'], + 'mac': instance.mac_address, + 'dns': [network['dns']], + 'ips': [ip_dict(ip) for ip in network_IPs], + 'ip6s': [ip6_dict(ip) for ip in network_IPs]} + tuple_list.append((network, info)) + + def inject_network_info(self, vm_ref, network_info): """ Generate the network info and make calls to place it into the xenstore and the xenstore param list - """ - vm_ref = self._get_vm_opaque_ref(instance.id) - logging.debug(_("injecting network info to xenstore for vm: |%s|"), - vm_ref) - if network_info is not None: - for (network, mapping) in network_info: - self.write_to_param_xenstore(vm_ref, {location: mapping}) - try: - self.write_to_xenstore(vm_ref, location, - mapping['location']) - except KeyError: - # catch KeyError for domid if instance isn't running - pass - else: - # TODO(tr3buchet) - this bit here when network_info is None goes - # away with multi-nic - admin_context = context.get_admin_context() - IPs = db.fixed_ip_get_all_by_instance(admin_context, - instance['id']) - networks = db.network_get_all_by_instance(admin_context, - instance['id']) - for network in networks: - network_IPs = [ip for ip in IPs if ip.network_id == network.id] - - def ip_dict(ip): - return { - "ip": ip.address, - "netmask": network["netmask"], - "enabled": "1"} - - def ip6_dict(ip6): - return { - "ip": ip6.addressV6, - "netmask": ip6.netmaskV6, - "gateway": ip6.gatewayV6, - "enabled": "1"} - - mac_id = instance.mac_address.replace(':', '') - location = 'vm-data/networking/%s' % mac_id - mapping = { - 'label': network['label'], - 'gateway': network['gateway'], - 'mac': instance.mac_address, - 'dns': [network['dns']], - 'ips': [ip_dict(ip) for ip in network_IPs], - 'ip6s': [ip6_dict(ip) for ip in network_IPs]} - - self.write_to_param_xenstore(vm_ref, {location: mapping}) - - try: - self.write_to_xenstore(vm_ref, location, - mapping['location']) - except KeyError: - # catch KeyError for domid if instance isn't running - pass - - return networks - - def create_vifs(self, instance, networks=None): - """ - Creates vifs for an instance + logging.debug(_("injecting network info to xs for vm: |%s|"), vm_ref) - """ - vm_ref = self._get_vm_opaque_ref(instance.id) + # make sure we have a vm opaque ref (raises otherwise) + self._session.get_xenapi().VM.get_record(vm_ref) + + for (network, info) in network_info: + location = 'vm-data/networking/%s' % info['mac'].replace(':', '') + self.write_to_param_xenstore(vm_ref, {location: info}) + try: + self.write_to_xenstore(vm_ref, location, info) + except KeyError: + # catch KeyError for domid if instance isn't running + pass + + def create_vifs(self, vm_ref, network_info): + """Creates vifs for an instance""" logging.debug(_("creating vif(s) for vm: |%s|"), vm_ref) - # TODO(tr3buchet) - goes away with multi-nic - if networks is None: - networks = db.network_get_all_by_instance(admin_context, - instance['id']) - # TODO(tr3buchet) - remove comment in multi-nic - # this bit here about creating the vifs will be updated - # in multi-nic to handle multiple IPs on the same network - # and multiple networks - # for now it works as there is only one of each - for network in networks: + + # make sure we have a vm opaque ref (raises otherwise) + self._session.get_xenapi().VM.get_record(vm_ref) + + device = 0 + for (network, info) in networks: + mac_address = info['mac'] bridge = network['bridge'] network_ref = \ NetworkHelper.find_network_with_bridge(self._session, bridge) - if network_ref: - try: - device = "1" if instance._rescue else "0" - except AttributeError: - device = "0" - - VMHelper.create_vif(self._session, vm_ref, network_ref, - instance.mac_address, device) + VMHelper.create_vif(self._session, vm_ref, network_ref, + mac_address, device) + device += 1 def reset_network(self, instance): - """ - Creates uuid arg to pass to make_agent_call and calls it. - - """ + """Creates uuid arg to pass to make_agent_call and calls it.""" args = {'id': str(uuid.uuid4())} resp = self._make_agent_call('resetnetwork', instance, '', args) -- cgit From d418926b514372f0f48922024e600bafcc657fd9 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Wed, 16 Mar 2011 12:50:11 -0500 Subject: forgot to return network info - teehee --- nova/virt/xenapi/vmops.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 485dd41ca..27f9a3a17 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -697,7 +697,7 @@ class VMOps(object): def _get_network_info(self, instance, networks, IPs): """creates network info list for instance""" - tuple_list = [] + network_info = [] for network in networks: network_IPs = [ip for ip in IPs if ip.network_id == network.id] @@ -714,8 +714,6 @@ class VMOps(object): "gateway": ip6.gatewayV6, "enabled": "1"} - mac_id = instance.mac_address.replace(':', '') - location = 'vm-data/networking/%s' % mac_id info = { 'label': network['label'], 'gateway': network['gateway'], @@ -723,7 +721,8 @@ class VMOps(object): 'dns': [network['dns']], 'ips': [ip_dict(ip) for ip in network_IPs], 'ip6s': [ip6_dict(ip) for ip in network_IPs]} - tuple_list.append((network, info)) + network_info.append((network, info)) + return network_info def inject_network_info(self, vm_ref, network_info): """ @@ -752,7 +751,7 @@ class VMOps(object): self._session.get_xenapi().VM.get_record(vm_ref) device = 0 - for (network, info) in networks: + for (network, info) in network_info: mac_address = info['mac'] bridge = network['bridge'] network_ref = \ -- cgit From a31e715617e5af107bc79caeedf0aff41f65fb07 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 12:57:45 -0500 Subject: The geebees --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index c292822ca..b449437c9 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -363,7 +363,7 @@ class VMOps(object): def resize_instance(self, instance, vdi_uuid): """Resize a running instance by changing it's RAM and disk size """ vm_ref = VMHelper.lookup(self._session, instance.name) - new_disk_size = instance.local_gb * 1024 + new_disk_size = str(instance.local_gb * 1024 * 1024) LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %d megs") % (vdi_uuid, instance.name, new_disk_size)) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) -- cgit From e2399c434386a31114273f2cf6f14586a25480c2 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 13:06:49 -0500 Subject: Derped again --- nova/virt/xenapi/vmops.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b449437c9..7f80de8a9 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -363,8 +363,10 @@ class VMOps(object): def resize_instance(self, instance, vdi_uuid): """Resize a running instance by changing it's RAM and disk size """ vm_ref = VMHelper.lookup(self._session, instance.name) - new_disk_size = str(instance.local_gb * 1024 * 1024) - LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %d megs") % (vdi_uuid, + + #The new disk size must be in bytes + new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) + LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %s megs") % (vdi_uuid, instance.name, new_disk_size)) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) -- cgit From 647f5f0d0283b3852115d821b80a965b0bc92c35 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 13:24:51 -0500 Subject: chchchchchanges --- nova/virt/xenapi/vmops.py | 19 ++++++++++--------- nova/virt/xenapi_conn.py | 3 ++- 2 files changed, 12 insertions(+), 10 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 7f80de8a9..6ff0aad15 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -72,7 +72,7 @@ class VMOps(object): LOG.debug(_("Starting instance %s"), instance.name) self._session.call_xenapi('VM.start', vm_ref, False, False) - def create_disk(self, instance): + def _create_disk(self, instance): user = AuthManager().get_user(instance.user_id) project = AuthManager().get_project(instance.project_id) disk_image_type = VMHelper.determine_disk_image_type(instance) @@ -81,11 +81,11 @@ class VMOps(object): return vdi_uuid def spawn(self, instance): - vdi_uuid = self.create_disk(instance) - self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) + vdi_uuid = self._create_disk(instance) + vm_ref = self._create_vm(instance, vdi_uuid) + self._spawn(instance, vm_ref) - def _spawn_with_disk(self, instance, vdi_uuid): - """Create VM instance""" + def _create_vm(self, instance, vdi_uuid): instance_name = instance.name vm_ref = VMHelper.lookup(self._session, instance_name) if vm_ref is not None: @@ -130,7 +130,10 @@ class VMOps(object): # inject_network_info and create vifs networks = self.inject_network_info(instance) self.create_vifs(instance, networks) + return vm_ref + def _spawn(self, instance, vm_ref): + """Spawn a new instance""" LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.') @@ -364,16 +367,14 @@ class VMOps(object): """Resize a running instance by changing it's RAM and disk size """ vm_ref = VMHelper.lookup(self._session, instance.name) + #TODO(mdietz): this will need to be adjusted for swap later #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %s megs") % (vdi_uuid, instance.name, new_disk_size)) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - #TODO(mdietz): this will need to be adjusted for swap later - task = self._session.call_xenapi('VDI.resize_online', vdi_ref, - new_disk_size) - self._session.wait_for_task(task, instance.id) + self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) LOG.debug(_("Resize instance %s complete") % (instance.name)) def reboot(self, instance): diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index b8256d205..fd68c0fe7 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -168,8 +168,9 @@ class XenAPIConnection(object): """Completes a resize, turning on the migrated instance""" vdi_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], disk_info['cow']) + self._vmops._create_vm(instance, vdi_uuid) self._vmops.resize_instance(instance, vdi_uuid) - self._vmops._spawn_with_disk(instance, vdi_uuid) + self._vmops._spawn_with_disk(instance) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From 11e7b6a08d1557a0986b480c032958cd30762f33 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 13:31:05 -0500 Subject: chchchchchanges --- nova/virt/xenapi/vmops.py | 2 -- nova/virt/xenapi_conn.py | 4 ++-- 2 files changed, 2 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6ff0aad15..92594c9c6 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -365,8 +365,6 @@ class VMOps(object): def resize_instance(self, instance, vdi_uuid): """Resize a running instance by changing it's RAM and disk size """ - vm_ref = VMHelper.lookup(self._session, instance.name) - #TODO(mdietz): this will need to be adjusted for swap later #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index fd68c0fe7..046f74c8d 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -168,9 +168,9 @@ class XenAPIConnection(object): """Completes a resize, turning on the migrated instance""" vdi_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], disk_info['cow']) - self._vmops._create_vm(instance, vdi_uuid) + vm_ref = self._vmops._create_vm(instance, vdi_uuid) self._vmops.resize_instance(instance, vdi_uuid) - self._vmops._spawn_with_disk(instance) + self._vmops._spawn(instance, vm_ref) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From d8c3ea5e6b594e6285650c5bdac6302b7be295dc Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 13:39:43 -0500 Subject: chchchchchanges --- nova/virt/xenapi/vmops.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 92594c9c6..931fc1cb4 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -136,6 +136,7 @@ class VMOps(object): """Spawn a new instance""" LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) + instance_name = instance.name LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.') % locals()) -- cgit From af754e3bba9b2ee93147a3533319ac5a5e199f45 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Wed, 16 Mar 2011 21:51:32 +0300 Subject: libvirt template and libvirt_conn.spawn modified in way that was proposed for xenapi multinic support --- nova/virt/libvirt.xml.template | 21 ++++--- nova/virt/libvirt_conn.py | 121 ++++++++++++++++++++++++++++++----------- 2 files changed, 100 insertions(+), 42 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 88bfbc668..43324c34b 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -69,21 +69,24 @@ #end if #end if + +#for $nic in $nics - - + + - - - -#if $getVar('extra_params', False) - ${extra_params} + + + +#if $getVar('nic.extra_params', False) + ${nic.extra_params} #end if -#if $getVar('ra_server', False) - +#if $getVar('nic.ra_server', False) + #end if +#end for diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7994e9547..c122ac8d4 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -412,16 +412,18 @@ class LibvirtConnection(object): # the normal xml file, we can just call reboot here self.reboot(instance) + # NOTE(ilyaalekseyev): Implementation like in multinics + # for xenapi(tr3buchet) @exception.wrap_exception - def spawn(self, instance): - xml = self.to_xml(instance) + def spawn(self, instance, network_info=None): + xml = self.to_xml(instance, network_info) db.instance_set_state(context.get_admin_context(), instance['id'], power_state.NOSTATE, 'launching') - self.firewall_driver.setup_basic_filtering(instance) - self.firewall_driver.prepare_instance_filter(instance) - self._create_image(instance, xml) + self.firewall_driver.setup_basic_filtering(instance, network_info) + self.firewall_driver.prepare_instance_filter(instance, network_info) + self._create_image(instance, xml, network_info) self._conn.createXML(xml, 0) LOG.debug(_("instance %s: is running"), instance['name']) self.firewall_driver.apply_instance_filter(instance) @@ -578,7 +580,8 @@ class LibvirtConnection(object): utils.execute('truncate', target, '-s', "%dG" % local_gb) # TODO(vish): should we format disk by default? - def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None): + def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None, + network_info=None): # syntactic nicety def basepath(fname='', suffix=suffix): return os.path.join(FLAGS.instances_path, @@ -690,17 +693,7 @@ class LibvirtConnection(object): if FLAGS.libvirt_type == 'uml': utils.execute('sudo', 'chown', 'root', basepath('disk')) - def to_xml(self, instance, rescue=False): - # TODO(termie): cache? - LOG.debug(_('instance %s: starting toXML method'), instance['name']) - network = db.network_get_by_instance(context.get_admin_context(), - instance['id']) - # FIXME(vish): stick this in db - instance_type = instance['instance_type'] - # instance_type = test.INSTANCE_TYPES[instance_type] - instance_type = instance_types.get_instance_type(instance_type) - ip_address = db.instance_get_fixed_address(context.get_admin_context(), - instance['id']) + def _get_nic_for_xml(self, instance_id, network, mapping): # Assume that the gateway also acts as the dhcp server. dhcp_server = network['gateway'] ra_server = network['ra_server'] @@ -728,6 +721,75 @@ class LibvirtConnection(object): (net, mask) else: extra_params = "\n" + + result = { + 'id': mapping['mac'].replace(':', ''), + 'bridge_name': network['bridge'], + 'mac_address': mapping['mac'], + 'ip_address': mapping['ips'][0]['ip'], + 'dhcp_server': dhcp_server, + 'extra_params': extra_params, + } + + if ra_server: + result['ra_server'] = ra_server + "/128" + + return result + + def to_xml(self, instance, rescue=False, network_info=None): + admin_context = context.get_admin_context() + + # TODO(termie): cache? + LOG.debug(_('instance %s: starting toXML method'), instance['name']) + + ip_addresses = db.fixed_ip_get_all_by_instance(admin_context, + instance['id']) + + networks = db.network_get_all_by_instance(admin_context, + instance['id']) + + #TODO(ilyaalekseyev) remove network_info creation code + # when multinics will be completed + if network_info is None: + network_info = [] + + def ip_dict(ip): + return { + "ip": ip.address, + "netmask": network["netmask"], + "enabled": "1"} + + def ip6_dict(ip6): + return { + "ip": ip6.addressV6, + "netmask": ip6.netmaskV6, + "gateway": ip6.gatewayV6, + "enabled": "1"} + + for network in networks: + network_ips = [ip for ip in ip_addresses + if ip.network_id == network.id] + + mapping = { + 'label': network['label'], + 'gateway': network['gateway'], + 'mac': instance.mac_address, + 'dns': [network['dns']], + 'ips': [ip_dict(ip) for ip in network_ips], + 'ip6s': [ip6_dict(ip) for ip in network_ips]} + + network_info.append((network, mapping)) + + nics = [] + for (network, mapping) in network_info: + nics.append(self._get_nic_for_xml(instance['id'], + network, + mapping)) + # FIXME(vish): stick this in db + instance_type = instance['instance_type'] + # instance_type = test.INSTANCE_TYPES[instance_type] + instance_type = instance_types.get_instance_type(instance_type) + if FLAGS.use_cow_images: driver_type = 'qcow2' else: @@ -739,17 +801,11 @@ class LibvirtConnection(object): instance['name']), 'memory_kb': instance_type['memory_mb'] * 1024, 'vcpus': instance_type['vcpus'], - 'bridge_name': network['bridge'], - 'mac_address': instance['mac_address'], - 'ip_address': ip_address, - 'dhcp_server': dhcp_server, - 'extra_params': extra_params, 'rescue': rescue, 'local': instance_type['local_gb'], - 'driver_type': driver_type} + 'driver_type': driver_type, + 'nics': nics} - if ra_server: - xml_info['ra_server'] = ra_server + "/128" if not rescue: if instance['kernel_id']: xml_info['kernel'] = xml_info['basepath'] + "/kernel" @@ -762,7 +818,6 @@ class LibvirtConnection(object): xml = str(Template(self.libvirt_xml, searchList=[xml_info])) LOG.debug(_('instance %s: finished toXML method'), instance['name']) - return xml def get_info(self, instance_name): @@ -1251,7 +1306,7 @@ class LibvirtConnection(object): class FirewallDriver(object): - def prepare_instance_filter(self, instance): + def prepare_instance_filter(self, instance, network_info=None): """Prepare filters for the instance. At this point, the instance isn't running yet.""" @@ -1285,7 +1340,7 @@ class FirewallDriver(object): the security group.""" raise NotImplementedError() - def setup_basic_filtering(self, instance): + def setup_basic_filtering(self, instance, network_info=None): """Create rules to block spoofing and allow dhcp. This gets called when spawning an instance, before @@ -1390,7 +1445,7 @@ class NWFilterFirewall(FirewallDriver): ''' - def setup_basic_filtering(self, instance): + def setup_basic_filtering(self, instance, network_info=None): """Set up basic filtering (MAC, IP, and ARP spoofing protection)""" logging.info('called setup_basic_filtering in nwfilter') @@ -1495,7 +1550,7 @@ class NWFilterFirewall(FirewallDriver): # Nothing to do pass - def prepare_instance_filter(self, instance): + def prepare_instance_filter(self, instance, network_info=None): """ Creates an NWFilter for the given instance. In the process, it makes sure the filters for the security groups as well as @@ -1598,9 +1653,9 @@ class IptablesFirewallDriver(FirewallDriver): self.iptables.ipv4['filter'].add_chain('sg-fallback') self.iptables.ipv4['filter'].add_rule('sg-fallback', '-j DROP') - def setup_basic_filtering(self, instance): + def setup_basic_filtering(self, instance, network_info=None): """Use NWFilter from libvirt for this.""" - return self.nwfilter.setup_basic_filtering(instance) + return self.nwfilter.setup_basic_filtering(instance, network_info) def apply_instance_filter(self, instance): """No-op. Everything is done in prepare_instance_filter""" @@ -1614,7 +1669,7 @@ class IptablesFirewallDriver(FirewallDriver): LOG.info(_('Attempted to unfilter instance %s which is not ' 'filtered'), instance['id']) - def prepare_instance_filter(self, instance): + def prepare_instance_filter(self, instance, network_info=None): self.instances[instance['id']] = instance self.add_filters_for_instance(instance) self.iptables.apply() -- cgit From 157ea09c03148ff4615bae27ca3f276a05620825 Mon Sep 17 00:00:00 2001 From: Christian Berendt Date: Wed, 16 Mar 2011 19:54:15 +0100 Subject: fixed pep8 issue --- nova/virt/libvirt_conn.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9943b742a..4e17555f4 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -995,7 +995,8 @@ class LibvirtConnection(object): cpu_info['model'] = xml.xpathEval('//host/cpu/model')[0].getContent() cpu_info['vendor'] = xml.xpathEval('//host/cpu/vendor')[0].getContent() - topology_node = xml.xpathEval('//host/cpu/topology')[0].get_properties() + topology_node = xml.xpathEval('//host/cpu/topology')[0]\ + .get_properties() topology = dict() while topology_node != None: name = topology_node.get_name() -- cgit From 007c2802e542bf954f0aa5b589f2adc3a1bfa89a Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 15:41:53 -0500 Subject: Reverting --- nova/virt/xenapi/vmops.py | 10 +++------- nova/virt/xenapi_conn.py | 8 ++++---- 2 files changed, 7 insertions(+), 11 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 931fc1cb4..7525ff5ec 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -85,7 +85,8 @@ class VMOps(object): vm_ref = self._create_vm(instance, vdi_uuid) self._spawn(instance, vm_ref) - def _create_vm(self, instance, vdi_uuid): + def _spawn(self, instance, vdi_uuid): + """Spawn a new instance""" instance_name = instance.name vm_ref = VMHelper.lookup(self._session, instance_name) if vm_ref is not None: @@ -130,13 +131,8 @@ class VMOps(object): # inject_network_info and create vifs networks = self.inject_network_info(instance) self.create_vifs(instance, networks) - return vm_ref - - def _spawn(self, instance, vm_ref): - """Spawn a new instance""" LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) - instance_name = instance.name LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.') % locals()) @@ -343,7 +339,7 @@ class VMOps(object): # sensible so we don't need to blindly pass around dictionaries return {'base_copy': base_copy_uuid, 'cow': cow_uuid} - def attach_disk(self, instance, base_copy_uuid, cow_uuid): + def link_disks(self, instance, base_copy_uuid, cow_uuid): """Links the base copy VHD to the COW via the XAPI plugin""" vm_ref = VMHelper.lookup(self._session, instance.name) new_base_copy_uuid = str(uuid.uuid4()) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 046f74c8d..99ec53c11 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -166,11 +166,11 @@ class XenAPIConnection(object): def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" - vdi_uuid = self._vmops.attach_disk(instance, disk_info['base_copy'], + vdi_uuid = self._vmops.link_disks(instance, disk_info['base_copy'], disk_info['cow']) - vm_ref = self._vmops._create_vm(instance, vdi_uuid) - self._vmops.resize_instance(instance, vdi_uuid) - self._vmops._spawn(instance, vm_ref) + #vm_ref = self._vmops._create_vm(instance, vdi_uuid) + #self._vmops.resize_instance(instance, vdi_uuid) + self._vmops._spawn(instance, vdi_uuid) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From 0e63a45f40a2069d497878b7c05d00522c3a2774 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 16:24:38 -0500 Subject: Again --- nova/virt/xenapi/vmops.py | 13 ++++++++----- nova/virt/xenapi_conn.py | 6 +++--- 2 files changed, 11 insertions(+), 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 7525ff5ec..ab98ef000 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -85,8 +85,7 @@ class VMOps(object): vm_ref = self._create_vm(instance, vdi_uuid) self._spawn(instance, vm_ref) - def _spawn(self, instance, vdi_uuid): - """Spawn a new instance""" + def _create_vm(self, instance, vdi_uuid): instance_name = instance.name vm_ref = VMHelper.lookup(self._session, instance_name) if vm_ref is not None: @@ -131,8 +130,13 @@ class VMOps(object): # inject_network_info and create vifs networks = self.inject_network_info(instance) self.create_vifs(instance, networks) + return vm_ref + + def _spawn(self, instance, vm_ref): + """Spawn a new instance""" LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) + instance_name = instance.name LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.') % locals()) @@ -365,10 +369,9 @@ class VMOps(object): #TODO(mdietz): this will need to be adjusted for swap later #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) - LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %s megs") % (vdi_uuid, - instance.name, new_disk_size)) + LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %sGB") % (vdi_uuid, + instance.name, instance.local_gb)) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) - self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) LOG.debug(_("Resize instance %s complete") % (instance.name)) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 99ec53c11..2b0f82a4a 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -168,9 +168,9 @@ class XenAPIConnection(object): """Completes a resize, turning on the migrated instance""" vdi_uuid = self._vmops.link_disks(instance, disk_info['base_copy'], disk_info['cow']) - #vm_ref = self._vmops._create_vm(instance, vdi_uuid) - #self._vmops.resize_instance(instance, vdi_uuid) - self._vmops._spawn(instance, vdi_uuid) + vm_ref = self._vmops._create_vm(instance, vdi_uuid) + self._vmops.resize_instance(instance, vdi_uuid) + self._vmops._spawn(instance, vm_ref) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From c7da5632e954c860defc322e971936a8d60eb8fd Mon Sep 17 00:00:00 2001 From: Cerberus Date: Wed, 16 Mar 2011 16:55:58 -0500 Subject: foo --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ab98ef000..9719e05b9 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -308,7 +308,7 @@ class VMOps(object): try: # transfer the base copy template_vm_ref, template_vdi_uuids = self._get_snapshot(instance) - base_copy_uuid = template_vdi_uuids['snap'] + base_copy_uuid = template_vdi_uuids['image'] vdi_ref, vm_vdi_rec = \ VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) cow_uuid = vm_vdi_rec['uuid'] -- cgit From adb9c0f0d933f8a56e688b89cfa632ce5c9e4888 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Wed, 16 Mar 2011 17:48:39 -0500 Subject: commit before monster --- nova/virt/xenapi/vmops.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 27f9a3a17..fbc7ab64d 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -761,10 +761,11 @@ class VMOps(object): mac_address, device) device += 1 - def reset_network(self, instance): + def reset_network(self, instance, vm_ref): """Creates uuid arg to pass to make_agent_call and calls it.""" args = {'id': str(uuid.uuid4())} - resp = self._make_agent_call('resetnetwork', instance, '', args) + resp = self._make_agent_call('resetnetwork', instance, '', args, + vm_ref) def list_from_xenstore(self, vm, path): """Runs the xenstore-ls command to get a listing of all records @@ -805,25 +806,27 @@ class VMOps(object): """ self._make_xenstore_call('delete_record', vm, path) - def _make_xenstore_call(self, method, vm, path, addl_args={}): + def _make_xenstore_call(self, method, vm, path, addl_args=None, + vm_ref=None): """Handles calls to the xenstore xenapi plugin.""" return self._make_plugin_call('xenstore.py', method=method, vm=vm, - path=path, addl_args=addl_args) + path=path, addl_args=addl_args, vm_ref=vm_ref) - def _make_agent_call(self, method, vm, path, addl_args={}): + def _make_agent_call(self, method, vm, path, addl_args=None, vm_ref=None): """Abstracts out the interaction with the agent xenapi plugin.""" return self._make_plugin_call('agent', method=method, vm=vm, - path=path, addl_args=addl_args) + path=path, addl_args=addl_args, vm_ref=vm_ref) - def _make_plugin_call(self, plugin, method, vm, path, addl_args={}): + def _make_plugin_call(self, plugin, method, vm, path, addl_args=None, + vm_ref=None): """Abstracts out the process of calling a method of a xenapi plugin. Any errors raised by the plugin will in turn raise a RuntimeError here. """ instance_id = vm.id - vm_ref = self._get_vm_opaque_ref(vm) + vm_ref = vm_ref or self._get_vm_opaque_ref(vm) vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) args = {'dom_id': vm_rec['domid'], 'path': path} - args.update(addl_args) + args.update(addl_args or {}) try: task = self._session.async_call_plugin(plugin, method, args) ret = self._session.wait_for_task(task, instance_id) -- cgit From 038d99d9fa4354bd617adfa332d69a87a9f7918e Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Wed, 16 Mar 2011 18:18:07 -0500 Subject: hacks in place --- nova/virt/xenapi/vmops.py | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index fbc7ab64d..a9a6800b1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -137,7 +137,7 @@ class VMOps(object): networks = db.network_get_all_by_instance(admin_context, instance['id']) network_info = self._get_network_info(instance, networks, IPs) - self.inject_network_info(vm_ref, network_info) + self.inject_network_info(instance, vm_ref, network_info) self.create_vifs(vm_ref, network_info) LOG.debug(_('Starting VM %s...'), vm_ref) @@ -188,7 +188,7 @@ class VMOps(object): timer.f = _wait_for_boot # call to reset network to configure network from xenstore - self.reset_network(instance) + self.reset_network(instance, vm_ref) return timer.start(interval=0.5, now=True) @@ -724,7 +724,7 @@ class VMOps(object): network_info.append((network, info)) return network_info - def inject_network_info(self, vm_ref, network_info): + def inject_network_info(self, instance, vm_ref, network_info): """ Generate the network info and make calls to place it into the xenstore and the xenstore param list @@ -738,7 +738,11 @@ class VMOps(object): location = 'vm-data/networking/%s' % info['mac'].replace(':', '') self.write_to_param_xenstore(vm_ref, {location: info}) try: - self.write_to_xenstore(vm_ref, location, info) + # TODO(tr3buchet): fix function call after refactor + #self.write_to_xenstore(vm_ref, location, info) + self._make_plugin_call('xenstore.py', 'write_record', instance, + location, {'value': json.dumps(info)}, + vm_ref) except KeyError: # catch KeyError for domid if instance isn't running pass @@ -764,8 +768,10 @@ class VMOps(object): def reset_network(self, instance, vm_ref): """Creates uuid arg to pass to make_agent_call and calls it.""" args = {'id': str(uuid.uuid4())} - resp = self._make_agent_call('resetnetwork', instance, '', args, - vm_ref) + # TODO(tr3buchet): fix function call after refactor + #resp = self._make_agent_call('resetnetwork', instance, '', args) + resp = self._make_plugin_call('agent', 'resetnetwork', instance, '', + args, vm_ref) def list_from_xenstore(self, vm, path): """Runs the xenstore-ls command to get a listing of all records @@ -806,16 +812,15 @@ class VMOps(object): """ self._make_xenstore_call('delete_record', vm, path) - def _make_xenstore_call(self, method, vm, path, addl_args=None, - vm_ref=None): + def _make_xenstore_call(self, method, vm, path, addl_args=None): """Handles calls to the xenstore xenapi plugin.""" return self._make_plugin_call('xenstore.py', method=method, vm=vm, - path=path, addl_args=addl_args, vm_ref=vm_ref) + path=path, addl_args=addl_args) - def _make_agent_call(self, method, vm, path, addl_args=None, vm_ref=None): + def _make_agent_call(self, method, vm, path, addl_args=None): """Abstracts out the interaction with the agent xenapi plugin.""" return self._make_plugin_call('agent', method=method, vm=vm, - path=path, addl_args=addl_args, vm_ref=vm_ref) + path=path, addl_args=addl_args) def _make_plugin_call(self, plugin, method, vm, path, addl_args=None, vm_ref=None): -- cgit From a766b4111addad804e47b8be3e6dedb5f80a83c4 Mon Sep 17 00:00:00 2001 From: Monsyne Dragon Date: Thu, 17 Mar 2011 02:20:18 +0000 Subject: added in network qos support for xenserver. Pull qos settings from flavor, use when creating instance. --- nova/virt/xenapi/vm_utils.py | 9 ++++++--- nova/virt/xenapi/vmops.py | 9 +++++++-- 2 files changed, 13 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 763c5fe40..e0621f73a 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -233,7 +233,9 @@ class VMHelper(HelperBase): raise StorageError(_('Unable to destroy VBD %s') % vbd_ref) @classmethod - def create_vif(cls, session, vm_ref, network_ref, mac_address, dev="0"): + def create_vif(cls, session, vm_ref, network_ref, mac_address, + dev="0", + rxtx_cap=0): """Create a VIF record. Returns a Deferred that gives the new VIF reference.""" vif_rec = {} @@ -243,8 +245,9 @@ class VMHelper(HelperBase): vif_rec['MAC'] = mac_address vif_rec['MTU'] = '1500' vif_rec['other_config'] = {} - vif_rec['qos_algorithm_type'] = '' - vif_rec['qos_algorithm_params'] = {} + vif_rec['qos_algorithm_type'] = "ratelimit" if rxtx_cap else '' + vif_rec['qos_algorithm_params'] = \ + {"kbps": str(rxtx_cap * 1024)} if rxtx_cap else {} LOG.debug(_('Creating VIF for VM %(vm_ref)s,' ' network %(network_ref)s.') % locals()) vif_ref = session.call_xenapi('VIF.create', vif_rec) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 488a61e8e..29f162ad1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -744,8 +744,12 @@ class VMOps(object): Creates vifs for an instance """ - vm_ref = self._get_vm_opaque_ref(instance.id) + vm_ref = self._get_vm_opaque_ref(instance['id']) + admin_context = context.get_admin_context() + flavor = db.instance_type_get_by_name(admin_context, + instance.instance_type) logging.debug(_("creating vif(s) for vm: |%s|"), vm_ref) + rxtx_cap = flavor['rxtx_cap'] if networks is None: networks = db.network_get_all_by_instance(admin_context, instance['id']) @@ -766,7 +770,8 @@ class VMOps(object): device = "0" VMHelper.create_vif(self._session, vm_ref, network_ref, - instance.mac_address, device) + instance.mac_address, device, + rxtx_cap=rxtx_cap) def reset_network(self, instance): """ -- cgit From 41619f49ce72d8e85f013c5a5dd248faa8490555 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 17 Mar 2011 11:44:27 +0100 Subject: Comparisons to None should not use == or !=. Stop converting sets to lists before comparing them. They might be in different order after being list()ified. --- nova/virt/libvirt_conn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 2559c2b81..0a85da541 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -998,14 +998,14 @@ class LibvirtConnection(object): topology_node = xml.xpathEval('//host/cpu/topology')[0]\ .get_properties() topology = dict() - while topology_node != None: + while topology_node: name = topology_node.get_name() topology[name] = topology_node.getContent() topology_node = topology_node.get_next() keys = ['cores', 'sockets', 'threads'] tkeys = topology.keys() - if list(set(tkeys)) != list(set(keys)): + if set(tkeys) != set(keys): ks = ', '.join(keys) raise exception.Invalid(_("Invalid xml: topology(%(topology)s) " "must have %(ks)s") % locals()) -- cgit From 7701edd34f1fc9fa26b3dfcc77ff87018622bedc Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 07:13:31 -0400 Subject: get_console_output is not supported by lxc and libvirt --- nova/virt/libvirt_conn.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index d08ca8b6a..9bfd3f841 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -490,6 +490,9 @@ class LibvirtConnection(object): instance['name']) data = self._flush_xen_console(virsh_output) fpath = self._append_to_file(data, console_log) + elif FLAGS.libvirt_type == 'lxc': + # LXC is also special + LOG.info(_("Unable to read LXC console")) else: fpath = console_log -- cgit From 9ba500c304595dff037da296f26cb13d02bfbc04 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 07:57:06 -0400 Subject: Fix pep8 errors --- nova/virt/disk.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index a44995613..26976940e 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -129,6 +129,7 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): % err) _unlink_device(device, nbd) + def destroy_container(target, instance, nbd=False): """Destroy the container once it terminates -- cgit From c98cead470f33041e928a6f82be801efeb94ccc3 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 08:52:52 -0400 Subject: Remove nbd=FLAGS.use_cow_images for destroy container --- nova/virt/disk.py | 7 +++---- nova/virt/libvirt_conn.py | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 26976940e..90d3cf499 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -23,7 +23,6 @@ Includes injection of SSH PGP keys into authorized_keys file. """ import os -import string import tempfile import time @@ -130,7 +129,7 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): _unlink_device(device, nbd) -def destroy_container(target, instance, nbd=False): +def destroy_container(target, instance): """Destroy the container once it terminates It will umount the container that is mounted, try to find the loopback @@ -140,9 +139,9 @@ def destroy_container(target, instance, nbd=False): container_dir = '%s/rootfs' % target utils.execute('sudo', 'umount', container_dir) finally: - for loop in os.popen('sudo losetup -a').readlines(): + for loop in utils.popen('sudo losetup -a').readlines(): if instance['name'] in loop: - device = string.split(loop, ':') + device = loop.split(loop, ':') utils.execute('sudo', 'losetup', '--detach', device) diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9bfd3f841..9e0d0538d 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -275,7 +275,7 @@ class LibvirtConnection(object): LOG.info(_('instance %(instance_name)s: deleting instance files' ' %(target)s') % locals()) if FLAGS.libvirt_type == 'lxc': - disk.destroy_container(target, instance, nbd=FLAGS.use_cow_images) + disk.destroy_container(target, instance) if os.path.exists(target): shutil.rmtree(target) -- cgit From 6bd017262a5c61d915ede2e58ef2758f1f190ff3 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 08:54:05 -0400 Subject: Remove target_partition for setup_container but still hardcode because its needed when you inject the keys into the image. --- nova/virt/libvirt_conn.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9e0d0538d..0ca27d629 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -700,8 +700,7 @@ class LibvirtConnection(object): if FLAGS.libvirt_type == 'lxc': disk.setup_container(basepath('disk'), container_dir=container_dir, - partition=target_partition, - nbd=FLAGS.use_cow_images) + partition=target_partition) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' -- cgit From 174d8ca2da7e2e53c9105ccc5e5d9a97bc12c0b8 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 09:17:42 -0400 Subject: Set nbd to false when mounting the image --- nova/virt/disk.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 90d3cf499..a84425de7 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -121,6 +121,7 @@ def setup_container(image, container_dir=None, partition=None, nbd=False): It will mount the loopback image to the container directory in order to create the root filesystem for the container """ + nbd=False device = _link_device(image, nbd) err = utils.execute('sudo', 'mount', device, container_dir) if err: -- cgit From bc0ef2c7aead759504eedcb4e2ab6d96dba7c266 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 10:02:40 -0400 Subject: Fix up setup container --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index a84425de7..2fa7819d7 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -115,7 +115,7 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): _unlink_device(device, nbd) -def setup_container(image, container_dir=None, partition=None, nbd=False): +def setup_container(image, container_dir=None, partition=None): """Setup the LXC container It will mount the loopback image to the container directory in order -- cgit From 36285d3acb940c39dc1827699c1e3c0cc9846529 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 10:22:57 -0400 Subject: Fix more pep8 errors --- nova/virt/disk.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 2fa7819d7..6c5f126bd 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -121,7 +121,7 @@ def setup_container(image, container_dir=None, partition=None): It will mount the loopback image to the container directory in order to create the root filesystem for the container """ - nbd=False + nbd = False device = _link_device(image, nbd) err = utils.execute('sudo', 'mount', device, container_dir) if err: @@ -132,7 +132,7 @@ def setup_container(image, container_dir=None, partition=None): def destroy_container(target, instance): """Destroy the container once it terminates - + It will umount the container that is mounted, try to find the loopback device associated with the container and delete it. """ -- cgit From cbcda1ec466fd498fb8e9fe47c72b52c2d4b3dde Mon Sep 17 00:00:00 2001 From: sateesh Date: Thu, 17 Mar 2011 20:13:48 +0530 Subject: 1) Update few comments where whitespace is missing after '#' 2) Update document so that copy right notice doesn't appear in generated document 3) Now using self.flag(...) instead of setting the flags like FLAGS.vmwareapi_username by direct assignment. 4) Added the missing double quote at the end a string in vim_util.py --- nova/virt/vmwareapi/fake.py | 24 ++++++++++++------------ nova/virt/vmwareapi/network_utils.py | 26 +++++++++++++------------- nova/virt/vmwareapi/vim.py | 2 +- nova/virt/vmwareapi/vim_util.py | 20 ++++++++++---------- 4 files changed, 36 insertions(+), 36 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py index 38585c714..80768ad2d 100644 --- a/nova/virt/vmwareapi/fake.py +++ b/nova/virt/vmwareapi/fake.py @@ -48,8 +48,8 @@ def log_db_contents(msg=None): def reset(): """Resets the db contents.""" for c in _CLASSES: - #We fake the datastore by keeping the file references as a list of - #names in the db + # We fake the datastore by keeping the file references as a list of + # names in the db if c == 'files': _db_content[c] = [] else: @@ -206,7 +206,7 @@ class VirtualMachine(ManagedObject): setting of the Virtual Machine object. """ try: - #Case of Reconfig of VM to attach disk + # Case of Reconfig of VM to attach disk controller_key = val.deviceChange[1].device.controllerKey filename = val.deviceChange[1].device.backing.fileName @@ -223,7 +223,7 @@ class VirtualMachine(ManagedObject): self.set("config.hardware.device", [disk, controller]) except Exception: - #Case of Reconfig of VM to set extra params + # Case of Reconfig of VM to set extra params self.set("config.extraConfig", val.extraConfig) @@ -406,14 +406,14 @@ def _remove_file(file_path): """Removes a file reference from the db.""" if _db_content.get("files", None) is None: raise exception.NotFound(_("No files have been added yet")) - #Check if the remove is for a single file object or for a folder + # Check if the remove is for a single file object or for a folder if file_path.find(".vmdk") != -1: if file_path not in _db_content.get("files"): raise exception.NotFound(_("File- '%s' is not there in the " "datastore") % file_path) _db_content.get("files").remove(file_path) else: - #Removes the files in the folder and the folder too from the db + # Removes the files in the folder and the folder too from the db for file in _db_content.get("files"): if file.find(file_path) != -1: try: @@ -639,15 +639,15 @@ class FakeVim(object): for obj in objs: try: obj_ref = obj.obj - #This means that we are doing a search for the managed - #dataobects of the type in the inventory + # This means that we are doing a search for the managed + # dataobjects of the type in the inventory if obj_ref == "RootFolder": for mdo_ref in _db_content[type]: mdo = _db_content[type][mdo_ref] - #Create a temp Managed object which has the same ref - #as the parent object and copies just the properties - #asked for. We need .obj along with the propSet of - #just the properties asked for + # Create a temp Managed object which has the same ref + # as the parent object and copies just the properties + # asked for. We need .obj along with the propSet of + # just the properties asked for temp_mdo = ManagedObject(mdo.objName, mdo.obj) for prop in properties: temp_mdo.set(prop, mdo.get(prop)) diff --git a/nova/virt/vmwareapi/network_utils.py b/nova/virt/vmwareapi/network_utils.py index 8d023d580..9232adab6 100644 --- a/nova/virt/vmwareapi/network_utils.py +++ b/nova/virt/vmwareapi/network_utils.py @@ -39,9 +39,9 @@ class NetworkHelper: hostsystems = session._call_method(vim_util, "get_objects", "HostSystem", ["network"]) vm_networks_ret = hostsystems[0].propSet[0].val - #Meaning there are no networks on the host. suds responds with a "" - #in the parent property field rather than a [] in the - #ManagedObjectRefernce property field of the parent + # Meaning there are no networks on the host. suds responds with a "" + # in the parent property field rather than a [] in the + # ManagedObjectRefernce property field of the parent if not vm_networks_ret: return None vm_networks = vm_networks_ret.ManagedObjectReference @@ -59,18 +59,18 @@ class NetworkHelper: Gets the vswitch associated with the physical network adapter with the name supplied. """ - #Get the list of vSwicthes on the Host System + # Get the list of vSwicthes on the Host System host_mor = session._call_method(vim_util, "get_objects", "HostSystem")[0].obj vswitches_ret = session._call_method(vim_util, "get_dynamic_property", host_mor, "HostSystem", "config.network.vswitch") - #Meaning there are no vSwitches on the host. Shouldn't be the case, - #but just doing code check + # Meaning there are no vSwitches on the host. Shouldn't be the case, + # but just doing code check if not vswitches_ret: return vswitches = vswitches_ret.HostVirtualSwitch - #Get the vSwitch associated with the network adapter + # Get the vSwitch associated with the network adapter for elem in vswitches: try: for nic_elem in elem.pnic: @@ -87,7 +87,7 @@ class NetworkHelper: physical_nics_ret = session._call_method(vim_util, "get_dynamic_property", host_net_system_mor, "HostNetworkSystem", "networkInfo.pnic") - #Meaning there are no physical nics on the host + # Meaning there are no physical nics on the host if not physical_nics_ret: return False physical_nics = physical_nics_ret.PhysicalNic @@ -139,11 +139,11 @@ class NetworkHelper: "AddPortGroup", network_system_mor, portgrp=add_prt_grp_spec) except error_util.VimFaultException, exc: - #There can be a race condition when two instances try - #adding port groups at the same time. One succeeds, then - #the other one will get an exception. Since we are - #concerned with the port group being created, which is done - #by the other call, we can ignore the exception. + # There can be a race condition when two instances try + # adding port groups at the same time. One succeeds, then + # the other one will get an exception. Since we are + # concerned with the port group being created, which is done + # by the other call, we can ignore the exception. if error_util.FAULT_ALREADY_EXISTS not in exc.fault_list: raise exception.Error(exc) LOG.debug(_("Created Port Group with name %s on " diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index 3430822e1..f384c96f9 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -29,7 +29,7 @@ from suds.sudsobject import Property from nova import flags from nova.virt.vmwareapi import error_util -RESP_NOT_XML_ERROR = 'Response is "text/html", not "text/xml' +RESP_NOT_XML_ERROR = 'Response is "text/html", not "text/xml"' CONN_ABORT_ERROR = 'Software caused connection abort' ADDRESS_IN_USE_ERROR = 'Address already in use' diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py index 709b54e12..a0088cb6d 100644 --- a/nova/virt/vmwareapi/vim_util.py +++ b/nova/virt/vmwareapi/vim_util.py @@ -45,46 +45,46 @@ def build_recursive_traversal_spec(client_factory): """ visit_folders_select_spec = build_selection_spec(client_factory, "visitFolders") - #For getting to hostFolder from datacnetr + # For getting to hostFolder from datacenter dc_to_hf = build_traversal_spec(client_factory, "dc_to_hf", "Datacenter", "hostFolder", False, [visit_folders_select_spec]) - #For getting to vmFolder from datacenter + # For getting to vmFolder from datacenter dc_to_vmf = build_traversal_spec(client_factory, "dc_to_vmf", "Datacenter", "vmFolder", False, [visit_folders_select_spec]) - #For getting Host System to virtual machine + # For getting Host System to virtual machine h_to_vm = build_traversal_spec(client_factory, "h_to_vm", "HostSystem", "vm", False, [visit_folders_select_spec]) - #For getting to Host System from Compute Resource + # For getting to Host System from Compute Resource cr_to_h = build_traversal_spec(client_factory, "cr_to_h", "ComputeResource", "host", False, []) - #For getting to datastore from Compute Resource + # For getting to datastore from Compute Resource cr_to_ds = build_traversal_spec(client_factory, "cr_to_ds", "ComputeResource", "datastore", False, []) rp_to_rp_select_spec = build_selection_spec(client_factory, "rp_to_rp") rp_to_vm_select_spec = build_selection_spec(client_factory, "rp_to_vm") - #For getting to resource pool from Compute Resource + # For getting to resource pool from Compute Resource cr_to_rp = build_traversal_spec(client_factory, "cr_to_rp", "ComputeResource", "resourcePool", False, [rp_to_rp_select_spec, rp_to_vm_select_spec]) - #For getting to child res pool from the parent res pool + # For getting to child res pool from the parent res pool rp_to_rp = build_traversal_spec(client_factory, "rp_to_rp", "ResourcePool", "resourcePool", False, [rp_to_rp_select_spec, rp_to_vm_select_spec]) - #For getting to Virtual Machine from the Resource Pool + # For getting to Virtual Machine from the Resource Pool rp_to_vm = build_traversal_spec(client_factory, "rp_to_vm", "ResourcePool", "vm", False, [rp_to_rp_select_spec, rp_to_vm_select_spec]) - #Get the assorted traversal spec which takes care of the objects to - #be searched for from the root folder + # Get the assorted traversal spec which takes care of the objects to + # be searched for from the root folder traversal_spec = build_traversal_spec(client_factory, "visitFolders", "Folder", "childEntity", False, [visit_folders_select_spec, dc_to_hf, -- cgit From b0e3b8e58a925ebf52fa741883f757ed2bc4383c Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 17 Mar 2011 10:47:19 -0400 Subject: more pep8 fixes --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 6c5f126bd..f6e6795d6 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -132,7 +132,7 @@ def setup_container(image, container_dir=None, partition=None): def destroy_container(target, instance): """Destroy the container once it terminates - + It will umount the container that is mounted, try to find the loopback device associated with the container and delete it. """ -- cgit From aa13754d04c17ae9985017e22ae4f68916bc2781 Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 17 Mar 2011 10:03:47 -0500 Subject: Foo --- nova/virt/xenapi/vmops.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 9719e05b9..b5003f0f8 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -307,7 +307,7 @@ class VMOps(object): template_vdi_uuids = template_vm_ref = None try: # transfer the base copy - template_vm_ref, template_vdi_uuids = self._get_snapshot(instance) + template_vm_ref, template_vdi_uuids = selimage._get_snapshot(instance) base_copy_uuid = template_vdi_uuids['image'] vdi_ref, vm_vdi_rec = \ VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) @@ -368,6 +368,7 @@ class VMOps(object): """Resize a running instance by changing it's RAM and disk size """ #TODO(mdietz): this will need to be adjusted for swap later #The new disk size must be in bytes + new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %sGB") % (vdi_uuid, instance.name, instance.local_gb)) -- cgit From ba0160cacac1c7db71eadd6624ee75a014c18378 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Thu, 17 Mar 2011 18:06:05 +0300 Subject: refactored: network_info creation extracted to method --- nova/virt/libvirt_conn.py | 74 +++++++++++++++++++++++++---------------------- 1 file changed, 40 insertions(+), 34 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index c122ac8d4..90bd5421c 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -154,6 +154,45 @@ def _get_ip_version(cidr): return int(net.version()) +def _get_network_info(instance): + admin_context = context.get_admin_context() + + ip_addresses = db.fixed_ip_get_all_by_instance(admin_context, + instance['id']) + + networks = db.network_get_all_by_instance(admin_context, + instance['id']) + network_info = [] + + def ip_dict(ip): + return { + "ip": ip.address, + "netmask": network["netmask"], + "enabled": "1"} + + def ip6_dict(ip6): + return { + "ip": ip6.addressV6, + "netmask": ip6.netmaskV6, + "gateway": ip6.gatewayV6, + "enabled": "1"} + + for network in networks: + network_ips = [ip for ip in ip_addresses + if ip.network_id == network.id] + + mapping = { + 'label': network['label'], + 'gateway': network['gateway'], + 'mac': instance.mac_address, + 'dns': [network['dns']], + 'ips': [ip_dict(ip) for ip in network_ips], + 'ip6s': [ip6_dict(ip) for ip in network_ips]} + + network_info.append((network, mapping)) + return network_info + + class LibvirtConnection(object): def __init__(self, read_only): @@ -742,43 +781,10 @@ class LibvirtConnection(object): # TODO(termie): cache? LOG.debug(_('instance %s: starting toXML method'), instance['name']) - ip_addresses = db.fixed_ip_get_all_by_instance(admin_context, - instance['id']) - - networks = db.network_get_all_by_instance(admin_context, - instance['id']) - #TODO(ilyaalekseyev) remove network_info creation code # when multinics will be completed if network_info is None: - network_info = [] - - def ip_dict(ip): - return { - "ip": ip.address, - "netmask": network["netmask"], - "enabled": "1"} - - def ip6_dict(ip6): - return { - "ip": ip6.addressV6, - "netmask": ip6.netmaskV6, - "gateway": ip6.gatewayV6, - "enabled": "1"} - - for network in networks: - network_ips = [ip for ip in ip_addresses - if ip.network_id == network.id] - - mapping = { - 'label': network['label'], - 'gateway': network['gateway'], - 'mac': instance.mac_address, - 'dns': [network['dns']], - 'ips': [ip_dict(ip) for ip in network_ips], - 'ip6s': [ip6_dict(ip) for ip in network_ips]} - - network_info.append((network, mapping)) + network_info = _get_network_info(instance) nics = [] for (network, mapping) in network_info: -- cgit From 720ba5d5c9ad2c24d9f0275fb783f191836a75f3 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Thu, 17 Mar 2011 18:22:48 +0300 Subject: bugfix --- nova/virt/libvirt_conn.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 90bd5421c..b26955d42 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -155,6 +155,8 @@ def _get_ip_version(cidr): def _get_network_info(instance): + #TODO(ilyaalekseyev) If we will keep this function + # we should cache network_info admin_context = context.get_admin_context() ip_addresses = db.fixed_ip_get_all_by_instance(admin_context, @@ -189,7 +191,7 @@ def _get_network_info(instance): 'ips': [ip_dict(ip) for ip in network_ips], 'ip6s': [ip6_dict(ip) for ip in network_ips]} - network_info.append((network, mapping)) + network_info.append((network, mapping)) return network_info -- cgit From ca50fdd2e013a9016b06a9d0263b980a062d5987 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 17 Mar 2011 16:27:08 +0100 Subject: Just use 'if foo' instead of 'if len(foo)'. It will fail as spectacularly if its not acting on a sequence anyways. --- nova/virt/libvirt_conn.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 96463d0f2..70a76b897 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -993,20 +993,20 @@ class LibvirtConnection(object): cpu_info = dict() arch_nodes = xml.xpathEval('//cpu/arch') - if len(arch_nodes): + if arch_nodes: cpu_info['arch'] = arch_nodes[0].getContent() model_nodes = xml.xpathEval('//cpu/model') - if len(model_nodes): + if model_nodes: cpu_info['model'] = model_nodes[0].getContent() vendor_nodes = xml.xpathEval('//cpu/vendor') - if len(vendor_nodes): + if vendor_nodes: cpu_info['vendor'] = vendor_nodes[0].getContent() topology_nodes = xml.xpathEval('//cpu/topology') topology = dict() - if len(topology_nodes): + if topology_nodes: topology_node = topology_nodes[0].get_properties() while topology_node != None: name = topology_node.get_name() -- cgit From 4f1f5bb1ed2cbb57e9ba8ea481ae31c0e6acc7bd Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 17 Mar 2011 11:03:07 -0500 Subject: refactoring --- nova/virt/xenapi/vmops.py | 22 +++++++++++++++++----- nova/virt/xenapi_conn.py | 10 +++++----- 2 files changed, 22 insertions(+), 10 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b5003f0f8..ee99a9918 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -62,6 +62,17 @@ class VMOps(object): vm_refs.append(vm_rec["name_label"]) return vm_refs + def revert_resize(self, instance): + vm_ref = VMHelper.lookup(self._session, instance.name) + self._start(instance, vm_ref) + + def finish_resize(self, instance, disk_info): + vdi_uuid = self._vmops.link_disks(instance, disk_info['base_copy'], + disk_info['cow']) + vm_ref = self._create_vm(instance, vdi_uuid) + self.resize_instance(instance, vdi_uuid) + self._spawn(instance, vm_ref) + def _start(self, instance, vm_ref=None): """Power on a VM instance""" if not vm_ref: @@ -307,7 +318,8 @@ class VMOps(object): template_vdi_uuids = template_vm_ref = None try: # transfer the base copy - template_vm_ref, template_vdi_uuids = selimage._get_snapshot(instance) + template_vm_ref, template_vdi_uuids = \ + self.image._get_snapshot(instance) base_copy_uuid = template_vdi_uuids['image'] vdi_ref, vm_vdi_rec = \ VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) @@ -370,8 +382,8 @@ class VMOps(object): #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) - LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %sGB") % (vdi_uuid, - instance.name, instance.local_gb)) + LOG.debug(_("Resizpng VDI %s for instance %s. Expanding to %sGB") % + (vdi_uuid, instance.name, instance.local_gb)) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) LOG.debug(_("Resize instance %s complete") % (instance.name)) @@ -451,8 +463,8 @@ class VMOps(object): state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: instance_name = instance.name - LOG.warn(_("VM %(instance_name)s already halted, skipping shutdown...") % - locals()) + LOG.warn(_("VM %(instance_name)s already halted," + "skipping shutdown...") % locals()) return instance_id = instance.id diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 2b0f82a4a..da2fb51f1 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -164,13 +164,13 @@ class XenAPIConnection(object): """Create VM instance""" self._vmops.spawn(instance) + def revert_resize(self, instance): + """Reverts a resize, powering back on the instance""" + self._vmops.revert_resize(instance) + def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" - vdi_uuid = self._vmops.link_disks(instance, disk_info['base_copy'], - disk_info['cow']) - vm_ref = self._vmops._create_vm(instance, vdi_uuid) - self._vmops.resize_instance(instance, vdi_uuid) - self._vmops._spawn(instance, vm_ref) + self._vmops.finish_resize(instance, disk_info) def snapshot(self, instance, image_id): """ Create snapshot from a running VM instance """ -- cgit From 1ffef31839f3c1f4386d5df834af6d53483c09ed Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 17 Mar 2011 11:16:59 -0500 Subject: oh come on --- nova/virt/xenapi/vmops.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index ee99a9918..b6bcc60ea 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -318,8 +318,7 @@ class VMOps(object): template_vdi_uuids = template_vm_ref = None try: # transfer the base copy - template_vm_ref, template_vdi_uuids = \ - self.image._get_snapshot(instance) + template_vm_ref, template_vdi_uuids = self._get_snapshot(instance) base_copy_uuid = template_vdi_uuids['image'] vdi_ref, vm_vdi_rec = \ VMHelper.get_vdi_for_vm_safely(self._session, vm_ref) -- cgit From d6ae8e4c2f6011497b1db23fcbafb23b663f924d Mon Sep 17 00:00:00 2001 From: Cerberus Date: Thu, 17 Mar 2011 11:24:24 -0500 Subject: Foo --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b6bcc60ea..326d43aa9 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -67,7 +67,7 @@ class VMOps(object): self._start(instance, vm_ref) def finish_resize(self, instance, disk_info): - vdi_uuid = self._vmops.link_disks(instance, disk_info['base_copy'], + vdi_uuid = self.link_disks(instance, disk_info['base_copy'], disk_info['cow']) vm_ref = self._create_vm(instance, vdi_uuid) self.resize_instance(instance, vdi_uuid) -- cgit From 1f99a95b8615e55c9828eb36e12b9aaa762470bb Mon Sep 17 00:00:00 2001 From: Eldar Nugaev Date: Thu, 17 Mar 2011 20:48:22 +0300 Subject: fixed IpTablesFirewal --- nova/virt/libvirt_conn.py | 88 +++++++++++++++++++++++++++++++++++------------ 1 file changed, 66 insertions(+), 22 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index b26955d42..fcaf8d879 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1663,6 +1663,8 @@ class IptablesFirewallDriver(FirewallDriver): def setup_basic_filtering(self, instance, network_info=None): """Use NWFilter from libvirt for this.""" + if not network_info: + network_info = _get_network_info(instance) return self.nwfilter.setup_basic_filtering(instance, network_info) def apply_instance_filter(self, instance): @@ -1678,28 +1680,47 @@ class IptablesFirewallDriver(FirewallDriver): 'filtered'), instance['id']) def prepare_instance_filter(self, instance, network_info=None): + if not network_info: + network_info = _get_network_info(instance) self.instances[instance['id']] = instance - self.add_filters_for_instance(instance) + self.add_filters_for_instance(instance, network_info) self.iptables.apply() - def add_filters_for_instance(self, instance): + def add_filters_for_instance(self, instance, network_info=None): + if not network_info: + network_info = _get_network_info(instance) chain_name = self._instance_chain_name(instance) self.iptables.ipv4['filter'].add_chain(chain_name) - ipv4_address = self._ip_for_instance(instance) - self.iptables.ipv4['filter'].add_rule('local', - '-d %s -j $%s' % - (ipv4_address, chain_name)) + + if network_info: + ips_v4 = [] + for (_n, mapping) in network_info: + for ip in mapping['ips']: + ips_v4.append(ip['ip']) + else: + ips_v4 = [self._ip_for_instance(instance)] + + for ipv4_address in ips_v4: + self.iptables.ipv4['filter'].add_rule('local', + '-d %s -j $%s' % + (ipv4_address, chain_name)) if FLAGS.use_ipv6: self.iptables.ipv6['filter'].add_chain(chain_name) - ipv6_address = self._ip_for_instance_v6(instance) - self.iptables.ipv6['filter'].add_rule('local', - '-d %s -j $%s' % - (ipv6_address, - chain_name)) + if network_info: + ips_v6 = [ip['ip'] for ip in mapping['ip6s'] for (_n, mapping) + in network_info] + else: + ips_v6 = [self._ip_for_instance_v6(instance)] + + for ipv6_address in ips_v6: + self.iptables.ipv6['filter'].add_rule('local', + '-d %s -j $%s' % + (ipv6_address, + chain_name)) - ipv4_rules, ipv6_rules = self.instance_rules(instance) + ipv4_rules, ipv6_rules = self.instance_rules(instance, network_info) for rule in ipv4_rules: self.iptables.ipv4['filter'].add_rule(chain_name, rule) @@ -1715,7 +1736,9 @@ class IptablesFirewallDriver(FirewallDriver): if FLAGS.use_ipv6: self.iptables.ipv6['filter'].remove_chain(chain_name) - def instance_rules(self, instance): + def instance_rules(self, instance, network_info=None): + if not network_info: + network_info = _get_network_info(instance) ctxt = context.get_admin_context() ipv4_rules = [] @@ -1729,28 +1752,49 @@ class IptablesFirewallDriver(FirewallDriver): ipv4_rules += ['-m state --state ESTABLISHED,RELATED -j ACCEPT'] ipv6_rules += ['-m state --state ESTABLISHED,RELATED -j ACCEPT'] - dhcp_server = self._dhcp_server_for_instance(instance) - ipv4_rules += ['-s %s -p udp --sport 67 --dport 68 ' - '-j ACCEPT' % (dhcp_server,)] + if network_info: + dhcp_servers = [network['gateway'] for (network, _m) + in network_info] + else: + dhcp_servers = [self._dhcp_server_for_instance(instance)] + + for dhcp_server in dhcp_servers: + ipv4_rules += ['-s %s -p udp --sport 67 --dport 68 ' + '-j ACCEPT' % (dhcp_server,)] #Allow project network traffic if FLAGS.allow_project_net_traffic: - cidr = self._project_cidr_for_instance(instance) - ipv4_rules += ['-s %s -j ACCEPT' % (cidr,)] + if network_info: + cidrs = [network['cidr'] for (network, _m) in network_info] + else: + cidrs = [self._project_cidr_for_instance(instance)] + for cidr in cidrs: + ipv4_rules += ['-s %s -j ACCEPT' % (cidr,)] # We wrap these in FLAGS.use_ipv6 because they might cause # a DB lookup. The other ones are just list operations, so # they're not worth the clutter. if FLAGS.use_ipv6: # Allow RA responses - ra_server = self._ra_server_for_instance(instance) - if ra_server: + if network_info: + ra_servers = [network['ra_server'] for (network, _m) + in network_info] + else: + ra_servers = [self._ra_server_for_instance(instance)] + + for ra_server in ra_servers: ipv6_rules += ['-s %s/128 -p icmpv6 -j ACCEPT' % (ra_server,)] #Allow project network traffic if FLAGS.allow_project_net_traffic: - cidrv6 = self._project_cidrv6_for_instance(instance) - ipv6_rules += ['-s %s -j ACCEPT' % (cidrv6,)] + if network_info: + cidrv6s = [network['cidr_v6'] for (network, _m) + in network_info] + else: + cidrv6s = [self._project_cidrv6_for_instance(instance)] + + for cidrv6 in cidrv6s: + ipv6_rules += ['-s %s -j ACCEPT' % (cidrv6,)] security_groups = db.security_group_get_by_instance(ctxt, instance['id']) -- cgit From 31388f18f8c0ebe3cae58ebd2a46e2bedb376fd4 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Thu, 17 Mar 2011 20:56:25 +0300 Subject: fixes for NWFilterFirewall and net injection --- nova/virt/interfaces.template | 18 +++++++------- nova/virt/libvirt_conn.py | 58 +++++++++++++++++++++++++++++-------------- 2 files changed, 49 insertions(+), 27 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/interfaces.template b/nova/virt/interfaces.template index 87b92b84a..7d40a0f69 100644 --- a/nova/virt/interfaces.template +++ b/nova/virt/interfaces.template @@ -5,13 +5,13 @@ auto lo iface lo inet loopback -# The primary network interface -auto eth0 -iface eth0 inet static - address %(address)s - netmask %(netmask)s - broadcast %(broadcast)s - gateway %(gateway)s - dns-nameservers %(dns)s - +#for $ifc in $interfaces +auto ${ifc.name} +iface ${ifc.name} inet static + address ${ifc.address} + netmask ${ifc.netmask} + broadcast ${ifc.broadcast} + gateway ${ifc.gateway} + dns-nameservers ${ifc.dns} +#end for diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index b26955d42..bc6c9f37d 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -623,6 +623,9 @@ class LibvirtConnection(object): def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None, network_info=None): + if network_info is None: + network_info = _get_network_info(inst) + # syntactic nicety def basepath(fname='', suffix=suffix): return os.path.join(FLAGS.instances_path, @@ -698,21 +701,32 @@ class LibvirtConnection(object): key = str(inst['key_data']) net = None - network_ref = db.network_get_by_instance(context.get_admin_context(), - inst['id']) - if network_ref['injected']: - admin_context = context.get_admin_context() - address = db.instance_get_fixed_address(admin_context, inst['id']) - ra_server = network_ref['ra_server'] - if not ra_server: - ra_server = "fd00::" - with open(FLAGS.injected_network_template) as f: - net = f.read() % {'address': address, - 'netmask': network_ref['netmask'], - 'gateway': network_ref['gateway'], - 'broadcast': network_ref['broadcast'], - 'dns': network_ref['dns'], - 'ra_server': ra_server} + #network_ref = db.network_get_by_instance(context.get_admin_context(), + # inst['id']) + + nets = [] + ifc_template = open(FLAGS.injected_network_template).read() + ifc_num = -1 + for (network_ref, _m) in network_info: + ifc_num += 1 + if network_ref['injected']: + admin_context = context.get_admin_context() + address = db.instance_get_fixed_address( + admin_context, inst['id']) + ra_server = network_ref['ra_server'] + if not ra_server: + ra_server = "fd00::" + net_info = {'name': 'eth%d' % ifc_num, + 'address': address, + 'netmask': network_ref['netmask'], + 'gateway': network_ref['gateway'], + 'broadcast': network_ref['broadcast'], + 'dns': network_ref['dns'], + 'ra_server': ra_server} + nets.append(net_info) + + net = str(Template(ifc_template, searchList=[{'interfaces': nets}])) + if key or net: inst_name = inst['name'] img_id = inst.image_id @@ -738,6 +752,7 @@ class LibvirtConnection(object): # Assume that the gateway also acts as the dhcp server. dhcp_server = network['gateway'] ra_server = network['ra_server'] + mac_id = mapping['mac'].replace(':', '') if FLAGS.allow_project_net_traffic: if FLAGS.use_ipv6: @@ -764,7 +779,7 @@ class LibvirtConnection(object): extra_params = "\n" result = { - 'id': mapping['mac'].replace(':', ''), + 'id': mac_id, 'bridge_name': network['bridge'], 'mac_address': mapping['mac'], 'ip_address': mapping['ips'][0]['ip'], @@ -1362,6 +1377,11 @@ class FirewallDriver(object): instance['id']) return network['ra_server'] + def _all_ra_servers_for_instance(selfself, instance): + networks = db.network_get_all_by_instance(context.get_admin_context(), + instance['id']) + return [network['ra_server'] for network in networks] + class NWFilterFirewall(FirewallDriver): """ @@ -1576,8 +1596,10 @@ class NWFilterFirewall(FirewallDriver): 'nova-base-ipv6', 'nova-allow-dhcp-server'] if FLAGS.use_ipv6: - ra_server = self._ra_server_for_instance(instance) - if ra_server: + #ra_server = self._ra_server_for_instance(instance) + ra_servers = self._all_ra_servers_for_instance(instance) + #if ra_server: + if len(ra_servers) != 0: instance_secgroup_filter_children += ['nova-allow-ra-server'] ctxt = context.get_admin_context() -- cgit From 192d3ad7bb9cf49abbca98b0d8e9ae822b204365 Mon Sep 17 00:00:00 2001 From: Monsyne Dragon Date: Thu, 17 Mar 2011 19:34:45 +0000 Subject: fixed code formatting nit. --- nova/virt/xenapi/vm_utils.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index e0621f73a..7dbca321f 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -234,8 +234,7 @@ class VMHelper(HelperBase): @classmethod def create_vif(cls, session, vm_ref, network_ref, mac_address, - dev="0", - rxtx_cap=0): + dev="0", rxtx_cap=0): """Create a VIF record. Returns a Deferred that gives the new VIF reference.""" vif_rec = {} -- cgit From d70bbdf43c4cba5a0b9c0ab93ff06031a2604db6 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 17 Mar 2011 21:03:11 +0100 Subject: I suck at merging. --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 998615fe9..7d6501406 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1004,7 +1004,7 @@ class LibvirtConnection(object): if vendor_nodes: cpu_info['vendor'] = vendor_nodes[0].getContent() - topology_nodes = xml.xpathEval('//cpu/topology') + topology_nodes = xml.xpathEval('//host/cpu/topology') topology = dict() if topology_nodes: topology_node = topology_nodes[0].get_properties() -- cgit From c89a477aa97bb4d716180cadd889ff98123625e4 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 17 Mar 2011 21:06:55 +0100 Subject: pep8 --- nova/virt/libvirt_conn.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7d6501406..ce54af498 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1017,9 +1017,9 @@ class LibvirtConnection(object): tkeys = topology.keys() if list(set(tkeys)) != list(set(keys)): ks = ', '.join(keys) - raise exception.Invalid(_("Invalid xml: topology(%(topology)s) " - "must have %(ks)s") % locals()) - + raise exception.Invalid(_("Invalid xml: topology" + "(%(topology)s) must have " + "%(ks)s") % locals()) feature_nodes = xml.xpathEval('//host/cpu/feature') features = list() -- cgit From a437ea845bd83c8b1da9de81253132cbad6b48b7 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 17 Mar 2011 16:14:48 -0500 Subject: create vifs before inject network info to remove rxtx_cap from network info (don't need to inject it) --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a35d36b9e..aff4fb445 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -133,8 +133,8 @@ class VMOps(object): # create it now. This goes away once nova-multi-nic hits. if network_info is None: network_info = self._get_network_info(instance) - self.inject_network_info(instance, vm_ref, network_info) self.create_vifs(vm_ref, network_info) + self.inject_network_info(instance, vm_ref, network_info) LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) -- cgit From b05bdeaf77ccb91ac59b4a2dde4a6cad94eb22b2 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Thu, 17 Mar 2011 16:17:03 -0500 Subject: syntax error --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index aff4fb445..6542630c1 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -698,7 +698,7 @@ class VMOps(object): networks = db.network_get_all_by_instance(admin_context, instance['id']) flavor = db.instance_type_get_by_name(admin_context, - instance.['instance_type']) + instance['instance_type']) network_info = [] for network in networks: network_IPs = [ip for ip in IPs if ip.network_id == network.id] -- cgit From cf648ea89015818a3ec7c8d6d59b50f8ed3604f7 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Thu, 17 Mar 2011 22:23:35 +0100 Subject: Fix mis-merge --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 2f6948556..e80b9fbdf 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1015,7 +1015,7 @@ class LibvirtConnection(object): keys = ['cores', 'sockets', 'threads'] tkeys = topology.keys() - if list(set(tkeys)) != list(set(keys)): + if set(tkeys) != set(keys): ks = ', '.join(keys) raise exception.Invalid(_("Invalid xml: topology" "(%(topology)s) must have " -- cgit From 745ade6a7759915eefe39eedc9be7e526df32547 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Fri, 18 Mar 2011 10:36:57 +0000 Subject: Fixed issue arisen from recent feature update (utils.execute) --- nova/virt/xenapi/vm_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index eaf5bb391..287a293f0 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -699,8 +699,8 @@ class VMHelper(HelperBase): try: out, err = utils.execute('sudo', 'mount', '-t', 'ext2,ext3', - '"%s"' % dev_path, - '"%s"' % tmpdir) + '%s' % dev_path, + '%s' % tmpdir) except exception.ProcessExecutionError as e: err = str(e) if err: -- cgit From c57908241e68a3f2a9f5eb4ee0fff6207962023d Mon Sep 17 00:00:00 2001 From: sateesh Date: Fri, 18 Mar 2011 17:20:46 +0530 Subject: Using eventlets greenthreads for optimized image processing. Fixed minor issues and style related nits. --- nova/virt/vmwareapi/fake.py | 4 +- nova/virt/vmwareapi/io_util.py | 168 +++++++++++++++++++++++++++++++++ nova/virt/vmwareapi/read_write_util.py | 48 ++++++++-- nova/virt/vmwareapi/vmops.py | 17 ++-- nova/virt/vmwareapi/vmware_images.py | 81 +++++++++++++--- nova/virt/vmwareapi_conn.py | 2 +- 6 files changed, 292 insertions(+), 28 deletions(-) create mode 100644 nova/virt/vmwareapi/io_util.py (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py index 80768ad2d..3afb46590 100644 --- a/nova/virt/vmwareapi/fake.py +++ b/nova/virt/vmwareapi/fake.py @@ -192,7 +192,9 @@ class VirtualMachine(ManagedObject): ds_do.ManagedObjectReference = [kwargs.get("ds").obj] self.set("datastore", ds_do) self.set("summary.guest.toolsStatus", kwargs.get("toolsstatus", - "toolsOk")) + "toolsOk")) + self.set("summary.guest.toolsRunningStatus", kwargs.get( + "toolsrunningstate", "guestToolsRunning")) self.set("runtime.powerState", kwargs.get("powerstate", "poweredOn")) self.set("config.files.vmPathName", kwargs.get("vmPathName")) self.set("summary.config.numCpu", kwargs.get("numCpu", 1)) diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py new file mode 100644 index 000000000..7f321c1e7 --- /dev/null +++ b/nova/virt/vmwareapi/io_util.py @@ -0,0 +1,168 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright (c) 2011 Citrix Systems, Inc. +# Copyright 2011 OpenStack LLC. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Utility classes for defining the time saving transfer of data from the reader +to the write using a LightQueue as a Pipe between the reader and the writer. +""" + +from eventlet import event +from eventlet import greenthread +from eventlet.queue import LightQueue + +from glance import client + +from nova import exception +from nova import log as logging + +LOG = logging.getLogger("nova.virt.vmwareapi.io_util") + +IO_THREAD_SLEEP_TIME = .01 +GLANCE_POLL_INTERVAL = 5 + + +class ThreadSafePipe(LightQueue): + """The pipe to hold the data which the reader writes to and the writer + reads from.""" + + def __init__(self, maxsize, transfer_size): + LightQueue.__init__(self, maxsize) + self.transfer_size = transfer_size + self.transferred = 0 + + def read(self, chunk_size): + """Read data from the pipe. Chunksize if ignored for we have ensured + that the data chunks written to the pipe by readers is the same as the + chunks asked for by the Writer.""" + if self.transferred < self.transfer_size: + data_item = self.get() + self.transferred += len(data_item) + return data_item + else: + return "" + + def write(self, data): + """Put a data item in the pipe.""" + self.put(data) + + def close(self): + """A place-holder to maintain consistency.""" + pass + + +class GlanceWriteThread(object): + """Ensures that image data is written to in the glance client and that + it is in correct ('active')state.""" + + def __init__(self, input, glance_client, image_id, image_meta={}): + self.input = input + self.glance_client = glance_client + self.image_id = image_id + self.image_meta = image_meta + self._running = False + + def start(self): + self.done = event.Event() + + def _inner(): + """Function to do the image data transfer through an update + and thereon checks if the state is 'active'.""" + self.glance_client.update_image(self.image_id, + image_meta=self.image_meta, + image_data=self.input) + self._running = True + while self._running: + try: + image_status = \ + self.glance_client.get_image_meta(self.image_id).get( + "status") + if image_status == "active": + self.stop() + self.done.send(True) + # If the state is killed, then raise an exception. + elif image_status == "killed": + self.stop() + exc_msg = _("Glance image %s is in killed state") %\ + self.image_id + LOG.exception(exc_msg) + self.done.send_exception(exception.Error(exc_msg)) + elif image_status in ["saving", "queued"]: + greenthread.sleep(GLANCE_POLL_INTERVAL) + else: + self.stop() + exc_msg = _("Glance image " + "%(image_id)s is in unknown state " + "- %(state)s") % { + "image_id": self.image_id, + "state": image_status} + LOG.exception(exc_msg) + self.done.send_exception(exception.Error(exc_msg)) + except Exception, exc: + self.stop() + self.done.send_exception(exc) + + greenthread.spawn(_inner) + return self.done + + def stop(self): + self._running = False + + def wait(self): + return self.done.wait() + + def close(self): + pass + + +class IOThread(object): + """Class that reads chunks from the input file and writes them to the + output file till the transfer is completely done.""" + + def __init__(self, input, output): + self.input = input + self.output = output + self._running = False + self.got_exception = False + + def start(self): + self.done = event.Event() + + def _inner(): + """Read data from the input and write the same to the output + until the transfer completes.""" + self._running = True + while self._running: + try: + data = self.input.read(None) + if not data: + self.stop() + self.done.send(True) + self.output.write(data) + greenthread.sleep(IO_THREAD_SLEEP_TIME) + except Exception, exc: + self.stop() + LOG.exception(exc) + self.done.send_exception(exc) + + greenthread.spawn(_inner) + return self.done + + def stop(self): + self._running = False + + def wait(self): + return self.done.wait() diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py index 52ed6f9ac..237fd44dc 100644 --- a/nova/virt/vmwareapi/read_write_util.py +++ b/nova/virt/vmwareapi/read_write_util.py @@ -27,16 +27,49 @@ import urllib import urllib2 import urlparse +from eventlet import event +from eventlet import greenthread + +from glance import client + from nova import flags from nova import log as logging -FLAGS = flags.FLAGS +LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util") -READ_CHUNKSIZE = 2 * 1024 * 1024 +FLAGS = flags.FLAGS USER_AGENT = "OpenStack-ESX-Adapter" -LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util") +try: + READ_CHUNKSIZE = client.BaseClient.CHUNKSIZE +except: + READ_CHUNKSIZE = 65536 + + +class GlanceFileRead(object): + """Glance file read handler class.""" + + def __init__(self, glance_read_iter): + self.glance_read_iter = glance_read_iter + self.iter = self.get_next() + + def read(self, chunk_size): + """Read an item from the queue. The chunk size is ignored for the + Client ImageBodyIterator uses its own CHUNKSIZE.""" + try: + return self.iter.next() + except StopIteration: + return "" + + def get_next(self): + """Get the next item from the image iterator.""" + for data in self.glance_read_iter: + yield data + + def close(self): + """A dummy close just to maintain consistency.""" + pass class VMwareHTTPFile(object): @@ -77,7 +110,7 @@ class VMwareHTTPFile(object): """Write data to the file.""" raise NotImplementedError - def read(self, chunk_size=READ_CHUNKSIZE): + def read(self, chunk_size): """Read a chunk of data.""" raise NotImplementedError @@ -137,9 +170,12 @@ class VmWareHTTPReadFile(VMwareHTTPFile): conn = urllib2.urlopen(request) VMwareHTTPFile.__init__(self, conn) - def read(self, chunk_size=READ_CHUNKSIZE): + def read(self, chunk_size): """Read a chunk of data.""" - return self.file_handle.read(chunk_size) + # We are ignoring the chunk size passed for we want the pipe to hold + # data items of the chunk-size that Glance Client uses for read + # while writing. + return self.file_handle.read(READ_CHUNKSIZE) def get_size(self): """Get size of the file to be read.""" diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index 4b3c8adca..e09b89e39 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -482,27 +482,32 @@ class VMWareVMOps(object): if vm_ref is None: raise exception.NotFound(_("instance - %s not present") % instance.name) - lst_properties = ["summary.guest.toolsStatus", "runtime.powerState"] + lst_properties = ["summary.guest.toolsStatus", "runtime.powerState", + "summary.guest.toolsRunningStatus"] props = self._session._call_method(vim_util, "get_object_properties", None, vm_ref, "VirtualMachine", lst_properties) + pwr_state = None + tools_status = None + tools_running_status = False for elem in props: - pwr_state = None - tools_status = None for prop in elem.propSet: if prop.name == "runtime.powerState": pwr_state = prop.val elif prop.name == "summary.guest.toolsStatus": tools_status = prop.val + elif prop.name == "summary.guest.toolsRunningStatus": + tools_running_status = prop.val # Raise an exception if the VM is not powered On. if pwr_state not in ["poweredOn"]: raise exception.Invalid(_("instance - %s not poweredOn. So can't " "be rebooted.") % instance.name) - # If vmware tools are installed in the VM, then do a guest reboot. - # Otherwise do a hard reset. - if tools_status not in ['toolsNotInstalled', 'toolsNotRunning']: + # If latest vmware tools are installed in the VM, and that the tools + # are running, then only do a guest reboot. Otherwise do a hard reset. + if (tools_status == "toolsOk" and + tools_running_status == "guestToolsRunning"): LOG.debug(_("Rebooting guest OS of VM %s") % instance.name) self._session._call_method(self._session._get_vim(), "RebootGuest", vm_ref) diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py index d9c7f52e5..50c6baedf 100644 --- a/nova/virt/vmwareapi/vmware_images.py +++ b/nova/virt/vmwareapi/vmware_images.py @@ -18,20 +18,70 @@ Utility functions for Image transfer. """ -import glance.client +from glance import client from nova import exception from nova import flags from nova import log as logging +from nova.virt.vmwareapi import io_util from nova.virt.vmwareapi import read_write_util -FLAGS = flags.FLAGS +LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images") -QUEUE_BUFFER_SIZE = 5 -READ_CHUNKSIZE = 2 * 1024 * 1024 -WRITE_CHUNKSIZE = 2 * 1024 * 1024 +FLAGS = flags.FLAGS -LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images") +QUEUE_BUFFER_SIZE = 10 + + +def start_transfer(read_file_handle, data_size, write_file_handle=None, + glance_client=None, image_id=None, image_meta={}): + """Start the data transfer from the reader to the writer. + Reader writes to the pipe and the writer reads from the pipe. This means + that the total transfer time boils down to the slower of the read/write + and not the addition of the two times.""" + # The pipe that acts as an intermediate store of data for reader to write + # to and writer to grab from. + thread_safe_pipe = io_util.ThreadSafePipe(QUEUE_BUFFER_SIZE, data_size) + # The read thread. In case of glance it is the instance of the + # GlanceFileRead class. The glance client read returns an iterator + # and this class wraps that iterator to provide datachunks in calls + # to read. + read_thread = io_util.IOThread(read_file_handle, thread_safe_pipe) + + # In case of Glance - VMWare transfer, we just need a handle to the + # HTTP Connection that is to send transfer data to the VMWare datastore. + if write_file_handle: + write_thread = io_util.IOThread(thread_safe_pipe, write_file_handle) + # In case of VMWare - Glance transfer, we relinquish VMWare HTTP file read + # handle to Glance Client instance, but to be sure of the transfer we need + # to be sure of the status of the image on glnace changing to active. + # The GlanceWriteThread handles the same for us. + elif glance_client and image_id: + write_thread = io_util.GlanceWriteThread(thread_safe_pipe, + glance_client, image_id, image_meta) + # Start the read and write threads. + read_event = read_thread.start() + write_event = write_thread.start() + try: + # Wait on the read and write events to signal their end + read_event.wait() + write_event.wait() + except Exception, exc: + # In case of any of the reads or writes raising an exception, + # stop the threads so that we un-necessarily don't keep the other one + # waiting. + read_thread.stop() + write_thread.stop() + + # Log and raise the exception. + LOG.exception(exc) + raise exception.Error(exc) + finally: + # No matter what, try closing the read and write handles, if it so + # applies. + read_file_handle.close() + if write_file_handle: + write_file_handle.close() def fetch_image(image, instance, **kwargs): @@ -67,8 +117,9 @@ def upload_image(image, instance, **kwargs): def _get_glance_image(image, instance, **kwargs): """Download image from the glance image server.""" LOG.debug(_("Downloading image %s from glance image server") % image) - glance_client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) - metadata, read_file_handle = glance_client.get_image(image) + glance_client = client.Client(FLAGS.glance_host, FLAGS.glance_port) + metadata, read_iter = glance_client.get_image(image) + read_file_handle = read_write_util.GlanceFileRead(read_iter) file_size = int(metadata['size']) write_file_handle = read_write_util.VMWareHTTPWriteFile( kwargs.get("host"), @@ -77,8 +128,8 @@ def _get_glance_image(image, instance, **kwargs): kwargs.get("cookies"), kwargs.get("file_path"), file_size) - for chunk in read_file_handle: - write_file_handle.write(chunk) + start_transfer(read_file_handle, file_size, + write_file_handle=write_file_handle) LOG.debug(_("Downloaded image %s from glance image server") % image) @@ -101,7 +152,9 @@ def _put_glance_image(image, instance, **kwargs): kwargs.get("datastore_name"), kwargs.get("cookies"), kwargs.get("file_path")) - glance_client = glance.client.Client(FLAGS.glance_host, FLAGS.glance_port) + file_size = read_file_handle.get_size() + glance_client = client.Client(FLAGS.glance_host, FLAGS.glance_port) + # The properties and other fields that we need to set for the image. image_metadata = {"is_public": True, "disk_format": "vmdk", "container_format": "bare", @@ -111,8 +164,8 @@ def _put_glance_image(image, instance, **kwargs): "vmware_ostype": kwargs.get("os_type"), "vmware_image_version": kwargs.get("image_version")}} - glance_client.update_image(image, image_meta=image_metadata, - image_data=read_file_handle) + start_transfer(read_file_handle, file_size, glance_client=glance_client, + image_id=image, image_meta=image_metadata) LOG.debug(_("Uploaded image %s to the Glance image server") % image) @@ -135,7 +188,7 @@ def get_vmdk_size_and_properties(image, instance): LOG.debug(_("Getting image size for the image %s") % image) if FLAGS.image_service == "nova.image.glance.GlanceImageService": - glance_client = glance.client.Client(FLAGS.glance_host, + glance_client = client.Client(FLAGS.glance_host, FLAGS.glance_port) meta_data = glance_client.get_image_meta(image) size, properties = meta_data["size"], meta_data["properties"] diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index bb10c6043..414b8731d 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -348,7 +348,7 @@ class VMWareAPISession(object): action["error"] = error_info LOG.warn(_("Task [%(task_name)s] %(task_ref)s " "status: error %(error_info)s") % locals()) - done.send_exception(Exception(error_info)) + done.send_exception(exception.Error(error_info)) db.instance_action_create(context.get_admin_context(), action) except Exception, excep: LOG.warn(_("In vmwareapi:_poll_task, Got this error %s") % excep) -- cgit From 70e8b431334989ad067f0a5543aea408b7186c5c Mon Sep 17 00:00:00 2001 From: Brian Lamar Date: Fri, 18 Mar 2011 10:34:08 -0400 Subject: Fixed 'Undefined variable' errors generated by pylint (E0602). --- nova/virt/fake.py | 2 +- nova/virt/libvirt_conn.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 3a06284a1..451760721 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -323,7 +323,7 @@ class FakeConnection(object): Note that this function takes an instance ID, not a compute.service.Instance, so that it can be called by compute.monitor. """ - return [0L, 0L, 0L, 0L, null] + return [0L, 0L, 0L, 0L, None] def interface_stats(self, instance_name, iface_id): """ diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e80b9fbdf..8a59c5bba 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -46,7 +46,7 @@ import time import uuid from xml.dom import minidom - +from eventlet import greenthread from eventlet import tpool from eventlet import semaphore -- cgit From 0c779999a36186ae58343e169db6f2e71c9a3200 Mon Sep 17 00:00:00 2001 From: sateesh Date: Fri, 18 Mar 2011 20:39:17 +0530 Subject: Minor fixes to replace occurances of "VI" by "VIM" in 2 comments. --- nova/virt/vmwareapi/error_util.py | 2 +- nova/virt/vmwareapi/vim.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/error_util.py b/nova/virt/vmwareapi/error_util.py index cf92c3493..f14cafed5 100644 --- a/nova/virt/vmwareapi/error_util.py +++ b/nova/virt/vmwareapi/error_util.py @@ -41,7 +41,7 @@ class SessionOverLoadException(VimException): class VimAttributeError(VimException): - """VI Attribute Error.""" + """VIM Attribute Error.""" pass diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index f384c96f9..61a0dd2b3 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -16,7 +16,7 @@ # under the License. """ -Classes for making VMware VI SOAP calls. +Classes that facilitate SOAP calls for VMware VI API. """ import httplib -- cgit From 9351bd5538ea0fc0a77c4dee13406ac7a71ca1ae Mon Sep 17 00:00:00 2001 From: Cerberus Date: Fri, 18 Mar 2011 17:01:44 -0500 Subject: Seriously? --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index b27fe2216..4dca26f61 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -383,7 +383,7 @@ class VMOps(object): #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) - LOG.debug(_("Resizpng VDI %s for instance %s. Expanding to %sGB") % + LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %sGB") % (vdi_uuid, instance.name, instance.local_gb)) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) -- cgit From ac66fde6d787742e9d5d6af9ebfe3302d9375073 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Fri, 18 Mar 2011 17:22:13 -0500 Subject: comment more descriptive --- nova/virt/xenapi/vmops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6542630c1..cfd74e5de 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -734,7 +734,7 @@ class VMOps(object): """ logging.debug(_("injecting network info to xs for vm: |%s|"), vm_ref) - # make sure we have a vm opaque ref (raises otherwise) + # this function raises if vm_ref is not a vm_opaque_ref self._session.get_xenapi().VM.get_record(vm_ref) for (network, info) in network_info: @@ -754,7 +754,7 @@ class VMOps(object): """Creates vifs for an instance""" logging.debug(_("creating vif(s) for vm: |%s|"), vm_ref) - # make sure we have a vm opaque ref (raises otherwise) + # this function raises if vm_ref is not a vm_opaque_ref self._session.get_xenapi().VM.get_record(vm_ref) device = 0 -- cgit From 6a893eabc83f4561025a9a655b0aabb2d3e1b3a7 Mon Sep 17 00:00:00 2001 From: Trey Morris Date: Mon, 21 Mar 2011 13:19:20 -0500 Subject: added an enumerate to track device in vmops.create_vifs() --- nova/virt/xenapi/vmops.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index cfd74e5de..61ff00903 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -757,8 +757,7 @@ class VMOps(object): # this function raises if vm_ref is not a vm_opaque_ref self._session.get_xenapi().VM.get_record(vm_ref) - device = 0 - for (network, info) in network_info: + for device, (network, info) in enumerate(network_info): mac_address = info['mac'] bridge = network['bridge'] rxtx_cap = info.pop('rxtx_cap') @@ -767,7 +766,6 @@ class VMOps(object): VMHelper.create_vif(self._session, vm_ref, network_ref, mac_address, device, rxtx_cap) - device += 1 def reset_network(self, instance, vm_ref): """Creates uuid arg to pass to make_agent_call and calls it.""" -- cgit From ffd2bc759af4f53019838bf20a4f016a566fbbd6 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 21 Mar 2011 13:21:26 -0500 Subject: Added XenAPI rescue unit tests --- nova/virt/xenapi/vmops.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 29f162ad1..18eec9544 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -85,6 +85,11 @@ class VMOps(object): vdi_uuid = self.create_disk(instance) self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) + def spawn_rescue(self, instance): + """Break rescue's spawn into separate method for unit tests""" + vdi_uuid = self.create_disk(instance) + self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) + def _spawn_with_disk(self, instance, vdi_uuid): """Create VM instance""" instance_name = instance.name @@ -600,7 +605,7 @@ class VMOps(object): """ rescue_vm_ref = VMHelper.lookup(self._session, - instance.name + "-rescue") + str(instance.name) + "-rescue") if rescue_vm_ref: raise RuntimeError(_( "Instance is already in Rescue Mode: %s" % instance.name)) @@ -610,7 +615,7 @@ class VMOps(object): self._acquire_bootlock(vm_ref) instance._rescue = True - self.spawn(instance) + self.spawn_rescue(instance) rescue_vm_ref = self._get_vm_opaque_ref(instance) vbd_ref = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0] @@ -628,7 +633,7 @@ class VMOps(object): """ rescue_vm_ref = VMHelper.lookup(self._session, - instance.name + "-rescue") + str(instance.name) + "-rescue") if not rescue_vm_ref: raise exception.NotFound(_( -- cgit From 0cff0a13bac3539a46b3b932bfd016df7f190196 Mon Sep 17 00:00:00 2001 From: Vishvananda Ishaya Date: Mon, 21 Mar 2011 14:20:13 -0700 Subject: import greenthread in libvirt --- nova/virt/libvirt_conn.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e80b9fbdf..f57f1a675 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -46,10 +46,9 @@ import time import uuid from xml.dom import minidom - +from eventlet import greenthread from eventlet import tpool from eventlet import semaphore - import IPy from nova import context -- cgit From 7cc28482a4ebeeb5dfa44c9e1c37bb135c1c66be Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 21 Mar 2011 17:00:08 -0500 Subject: Remove dupe'd code --- nova/virt/xenapi/vmops.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 18eec9544..a5f43200d 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -86,9 +86,8 @@ class VMOps(object): self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) def spawn_rescue(self, instance): - """Break rescue's spawn into separate method for unit tests""" - vdi_uuid = self.create_disk(instance) - self._spawn_with_disk(instance, vdi_uuid=vdi_uuid) + """Spawn a rescue instance""" + self.spawn(instance) def _spawn_with_disk(self, instance, vdi_uuid): """Create VM instance""" -- cgit From 8db9e359d85cbf8e9afab2260759543b1717c3f9 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Mon, 21 Mar 2011 17:56:30 -0500 Subject: Remove _get_vm_opaque_ref() calls in rescue/unrescue --- nova/virt/xenapi/vmops.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a5f43200d..c2ead3f57 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -609,13 +609,13 @@ class VMOps(object): raise RuntimeError(_( "Instance is already in Rescue Mode: %s" % instance.name)) - vm_ref = self._get_vm_opaque_ref(instance) + vm_ref = VMHelper.lookup(self._session, instance.name) self._shutdown(instance, vm_ref) self._acquire_bootlock(vm_ref) instance._rescue = True self.spawn_rescue(instance) - rescue_vm_ref = self._get_vm_opaque_ref(instance) + rescue_vm_ref = VMHelper.lookup(self._session, instance.name) vbd_ref = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0] vdi_ref = self._session.get_xenapi().VBD.get_record(vbd_ref)["VDI"] @@ -638,7 +638,7 @@ class VMOps(object): raise exception.NotFound(_( "Instance is not in Rescue Mode: %s" % instance.name)) - original_vm_ref = self._get_vm_opaque_ref(instance) + original_vm_ref = VMHelper.lookup(self._session, instance.name) vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref) instance._rescue = False -- cgit From 62f9cc7cee30332143bf4e6e54fd21335db3c8da Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Tue, 22 Mar 2011 14:36:32 +0100 Subject: Convert _cache_image to use utils.synchronized decorator. Disable its test case, since I think it is no longer needed with the tests for synchronized. --- nova/virt/libvirt_conn.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e80b9fbdf..ca8d81f5f 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -48,7 +48,6 @@ from xml.dom import minidom from eventlet import tpool -from eventlet import semaphore import IPy @@ -552,13 +551,12 @@ class LibvirtConnection(object): os.mkdir(base_dir) base = os.path.join(base_dir, fname) - if fname not in LibvirtConnection._image_sems: - LibvirtConnection._image_sems[fname] = semaphore.Semaphore() - with LibvirtConnection._image_sems[fname]: + @utils.synchronized(fname) + def call_if_not_exists(base, fn, *args, **kwargs): if not os.path.exists(base): fn(target=base, *args, **kwargs) - if not LibvirtConnection._image_sems[fname].locked(): - del LibvirtConnection._image_sems[fname] + + call_if_not_exists(base, fn, *args, **kwargs) if cow: utils.execute('qemu-img', 'create', '-f', 'qcow2', '-o', -- cgit From 01e7e598d0eb4aab9c3e7f69926a2875cdf22136 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Tue, 22 Mar 2011 14:39:35 +0100 Subject: Get rid of IptablesManager's explicit semaphore. --- nova/virt/libvirt_conn.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index ca8d81f5f..902866167 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1766,14 +1766,11 @@ class IptablesFirewallDriver(FirewallDriver): def refresh_security_group_members(self, security_group): pass + @utils.synchronized('iptables', external=True) def refresh_security_group_rules(self, security_group): - # We use the semaphore to make sure noone applies the rule set - # after we've yanked the existing rules but before we've put in - # the new ones. - with self.iptables.semaphore: - for instance in self.instances.values(): - self.remove_filters_for_instance(instance) - self.add_filters_for_instance(instance) + for instance in self.instances.values(): + self.remove_filters_for_instance(instance) + self.add_filters_for_instance(instance) self.iptables.apply() def _security_group_chain_name(self, security_group_id): -- cgit From de2ecf115ff0baf43fa530807997513c728ffdaf Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Tue, 22 Mar 2011 15:16:08 +0100 Subject: Fix locking problem in security group refresh code. --- nova/virt/libvirt_conn.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 902866167..fcd78b3b2 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1766,12 +1766,15 @@ class IptablesFirewallDriver(FirewallDriver): def refresh_security_group_members(self, security_group): pass - @utils.synchronized('iptables', external=True) def refresh_security_group_rules(self, security_group): + self.do_refresh_security_group_rules(security_group) + self.iptables.apply() + + @utils.synchronized('iptables', external=True) + def do_refresh_security_group_rules(self, security_group): for instance in self.instances.values(): self.remove_filters_for_instance(instance) self.add_filters_for_instance(instance) - self.iptables.apply() def _security_group_chain_name(self, security_group_id): return 'nova-sg-%s' % (security_group_id,) -- cgit From 3c7de6db490a8482f6d1fb5fefc750050cb1e269 Mon Sep 17 00:00:00 2001 From: Soren Hansen Date: Tue, 22 Mar 2011 16:42:37 +0100 Subject: Pass a fake timing source to test_ensure_filtering_rules_for_instance_timeout, shaving off 30 seconds of test run time. --- nova/virt/libvirt_conn.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e80b9fbdf..de4a8fbca 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -42,13 +42,13 @@ import shutil import sys import random import subprocess -import time import uuid from xml.dom import minidom -from eventlet import tpool +from eventlet import greenthread from eventlet import semaphore +from eventlet import tpool import IPy @@ -1133,7 +1133,8 @@ class LibvirtConnection(object): return - def ensure_filtering_rules_for_instance(self, instance_ref): + def ensure_filtering_rules_for_instance(self, instance_ref, + time=None): """Setting up filtering rules and waiting for its completion. To migrate an instance, filtering rules to hypervisors @@ -1157,6 +1158,9 @@ class LibvirtConnection(object): """ + if not time: + time = greenthread + # If any instances never launch at destination host, # basic-filtering must be set here. self.firewall_driver.setup_basic_filtering(instance_ref) -- cgit From 116c0d52d21ebd6ed55a61467aac5d8c06a4b086 Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Tue, 22 Mar 2011 17:46:17 +0000 Subject: Merge stuff --- nova/virt/xenapi/vmops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 1f5d2d155..c1a65c997 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -387,8 +387,8 @@ class VMOps(object): #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) - LOG.debug(_("Resizing VDI %s for instance %s. Expanding to %sGB"), - (vdi_uuid, instance.name, instance.local_gb)) + LOG.debug(_("Resizing VDI %(vdi_uuid) for instance %(instance.name). " + "Expanding to %(instance.local_gb)GB") % locals()) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) LOG.debug(_("Resize instance %s complete") % (instance.name)) -- cgit From 3b3889a19c4efa8dc917f772613543780f361df3 Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Tue, 22 Mar 2011 17:55:40 +0000 Subject: tweak --- nova/virt/xenapi/vmops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index c1a65c997..8ac944966 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -387,8 +387,8 @@ class VMOps(object): #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) - LOG.debug(_("Resizing VDI %(vdi_uuid) for instance %(instance.name). " - "Expanding to %(instance.local_gb)GB") % locals()) + LOG.debug(_("Resizing VDI %(vdi_uuid) for instance %(instance.name)s. " + "Expanding to %(instance.local_gb)f GB") % locals()) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) LOG.debug(_("Resize instance %s complete") % (instance.name)) -- cgit From 4c76bcc12954734d19afcb5e4519e35c23e39d6d Mon Sep 17 00:00:00 2001 From: "matt.dietz@rackspace.com" <> Date: Tue, 22 Mar 2011 18:04:09 +0000 Subject: tweak --- nova/virt/xenapi/vmops.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 8ac944966..383096d63 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -387,8 +387,10 @@ class VMOps(object): #The new disk size must be in bytes new_disk_size = str(instance.local_gb * 1024 * 1024 * 1024) - LOG.debug(_("Resizing VDI %(vdi_uuid) for instance %(instance.name)s. " - "Expanding to %(instance.local_gb)f GB") % locals()) + instance_name = instance.name + instance_local_gb = instance.local_gb + LOG.debug(_("Resizing VDI %(vdi_uuid)s for instance %(instance_name)s." + " Expanding to %(instance_local_gb)d GB") % locals()) vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid) self._session.call_xenapi('VDI.resize_online', vdi_ref, new_disk_size) LOG.debug(_("Resize instance %s complete") % (instance.name)) -- cgit From 4ba57654ca03d687da3b994c127665c7118ab9a5 Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Tue, 22 Mar 2011 13:26:23 -0700 Subject: intermediate progress on vnc-nova integration. checking in to show vish. --- nova/virt/libvirt.xml.template | 4 +++- nova/virt/libvirt_conn.py | 2 ++ 2 files changed, 5 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 7b4c23211..037cd0902 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -101,6 +101,8 @@ - +#if $getVar('vnc_host_iface', False) + +#end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4fca84639..51f263ce9 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -734,6 +734,8 @@ class LibvirtConnection(object): 'local': instance_type['local_gb'], 'driver_type': driver_type} + if FLAGS.vnc_enabled: + xml_info['vnc_host_iface'] = FLAGS.vnc_host_iface if ra_server: xml_info['ra_server'] = ra_server + "/128" if not rescue: -- cgit From 365b98f4d52740ef85f8a8f098a32e441d7ac168 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 22 Mar 2011 21:42:17 -0700 Subject: Renamed check_instance -> check_isinstance to make intent clearer --- nova/virt/connection.py | 2 +- nova/virt/fake.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/connection.py b/nova/virt/connection.py index d585b6c21..4ba31c7a7 100644 --- a/nova/virt/connection.py +++ b/nova/virt/connection.py @@ -74,4 +74,4 @@ def get_connection(read_only=False): if conn is None: LOG.error(_('Failed to open connection to the hypervisor')) sys.exit(1) - return utils.check_instance(conn, driver.ComputeDriver) + return utils.check_isinstance(conn, driver.ComputeDriver) diff --git a/nova/virt/fake.py b/nova/virt/fake.py index e0e2369c7..57b02e00b 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -100,7 +100,7 @@ class FakeConnection(driver.ComputeDriver): return self.instances.keys() def _map_to_instance_info(self, instance): - instance = utils.check_instance(instance, FakeInstance) + instance = utils.check_isinstance(instance, FakeInstance) info = driver.InstanceInfo(instance.name, instance.state) return info -- cgit From 19da125805eedbfcfd202abac4a90c57e6c538c4 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 22 Mar 2011 22:38:37 -0700 Subject: Filled out the base-driver contract, so it's not a false-promise --- nova/virt/driver.py | 228 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 nova/virt/driver.py (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py new file mode 100644 index 000000000..6c1b97ce9 --- /dev/null +++ b/nova/virt/driver.py @@ -0,0 +1,228 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 Justin Santa Barbara +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Driver base-classes: + + (Beginning of) the contract that compute drivers must follow, and shared + types that support that contract +""" + +from nova.compute import power_state + + +class InstanceInfo(object): + def __init__(self, name, state): + self.name = name + assert state in power_state.valid_states() + self.state = state + + +class ComputeDriver(object): + """Base class for compute drivers.""" + + def init_host(self, host): + """Adopt existing VM's running here""" + raise NotImplementedError() + + def get_info(self, instance_name): + """Get the current status of an instance, by name (not ID!) + + Returns a dict containing: + :state: the running state, one of the power_state codes + :max_mem: (int) the maximum memory in KBytes allowed + :mem: (int) the memory in KBytes used by the domain + :num_cpu: (int) the number of virtual CPUs for the domain + :cpu_time: (int) the CPU time used in nanoseconds + """ + raise NotImplementedError() + + def list_instances(self): + raise NotImplementedError() + + def list_instances_detail(self): + """Return a list of InstanceInfo for all registered VMs""" + raise NotImplementedError() + + def spawn(self, instance): + """Launch a VM for the specified instance""" + raise NotImplementedError() + + def destroy(self, instance, cleanup=True): + """Shutdown specified VM""" + raise NotImplementedError() + + def reboot(self, instance): + """Reboot specified VM""" + raise NotImplementedError() + + def snapshot_instance(self, context, instance_id, image_id): + raise NotImplementedError() + + def get_console_pool_info(self, console_type): + """??? + + Returns a dict containing: + :address: ??? + :username: ??? + :password: ??? + """ + raise NotImplementedError() + + def get_console_output(self, instance): + raise NotImplementedError() + + def get_ajax_console(self, instance): + raise NotImplementedError() + + def get_diagnostics(self, instance): + """Return data about VM diagnostics""" + raise NotImplementedError() + + def get_host_ip_addr(self): + raise NotImplementedError() + + def attach_volume(self, context, instance_id, volume_id, mountpoint): + raise NotImplementedError() + + def detach_volume(self, context, instance_id, volume_id): + raise NotImplementedError() + + def compare_cpu(self, context, cpu_info): + raise NotImplementedError() + + def migrate_disk_and_power_off(self, instance, dest): + """Transfers the VHD of a running instance to another host, then shuts + off the instance copies over the COW disk""" + raise NotImplementedError() + + def snapshot(self, instance, image_id): + """ Create snapshot from a running VM instance """ + raise NotImplementedError() + + def finish_resize(self, instance, disk_info): + """Completes a resize, turning on the migrated instance""" + raise NotImplementedError() + + def pause(self, instance, callback): + """Pause VM instance""" + raise NotImplementedError() + + def unpause(self, instance, callback): + """Unpause paused VM instance""" + raise NotImplementedError() + + def suspend(self, instance, callback): + """suspend the specified instance""" + raise NotImplementedError() + + def resume(self, instance, callback): + """resume the specified instance""" + raise NotImplementedError() + + def rescue(self, instance, callback): + """Rescue the specified instance""" + raise NotImplementedError() + + def unrescue(self, instance, callback): + """Unrescue the specified instance""" + raise NotImplementedError() + + def update_available_resource(self, ctxt, host): + """Updates compute manager resource info on ComputeNode table. + + This method is called when nova-compute launches, and + whenever admin executes "nova-manage service update_resource". + + :param ctxt: security context + :param host: hostname that compute manager is currently running + + """ + raise NotImplementedError() + + def live_migration(self, ctxt, instance_ref, dest, + post_method, recover_method): + """Spawning live_migration operation for distributing high-load. + + :params ctxt: security context + :params instance_ref: + nova.db.sqlalchemy.models.Instance object + instance object that is migrated. + :params dest: destination host + :params post_method: + post operation method. + expected nova.compute.manager.post_live_migration. + :params recover_method: + recovery method when any exception occurs. + expected nova.compute.manager.recover_live_migration. + + """ + raise NotImplementedError() + + def refresh_security_group_rules(self, security_group_id): + raise NotImplementedError() + + def refresh_security_group_members(self, security_group_id): + raise NotImplementedError() + + def reset_network(self, instance): + """reset networking for specified instance""" + raise NotImplementedError() + + def ensure_filtering_rules_for_instance(self, instance_ref): + """Setting up filtering rules and waiting for its completion. + + To migrate an instance, filtering rules to hypervisors + and firewalls are inevitable on destination host. + ( Waiting only for filtering rules to hypervisor, + since filtering rules to firewall rules can be set faster). + + Concretely, the below method must be called. + - setup_basic_filtering (for nova-basic, etc.) + - prepare_instance_filter(for nova-instance-instance-xxx, etc.) + + to_xml may have to be called since it defines PROJNET, PROJMASK. + but libvirt migrates those value through migrateToURI(), + so , no need to be called. + + Don't use thread for this method since migration should + not be started when setting-up filtering rules operations + are not completed. + + :params instance_ref: nova.db.sqlalchemy.models.Instance object + + """ + raise NotImplementedError() + + def unfilter_instance(self, instance): + """Stop filtering instance""" + raise NotImplementedError() + + def set_admin_password(self, context, instance_id, new_pass=None): + """Set the root/admin password for an instance on this server.""" + raise NotImplementedError() + + def inject_file(self, instance, b64_path, b64_contents): + """Create a file on the VM instance. The file path and contents + should be base64-encoded. + """ + raise NotImplementedError() + + def inject_network_info(self, instance): + """inject network info for specified instance""" + raise NotImplementedError() + -- cgit From a4d78e44d7ca35a6cca4454667cab743409fd95a Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 22 Mar 2011 22:45:15 -0700 Subject: Added space in between # and TODO in #TODO --- nova/virt/hyperv.py | 2 +- nova/virt/xenapi/vmops.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py index 435272109..21e21ec13 100644 --- a/nova/virt/hyperv.py +++ b/nova/virt/hyperv.py @@ -127,7 +127,7 @@ class HyperVConnection(driver.ComputeDriver): return vms def list_instances_detail(self): - #TODO(justinsb): This is a terrible implementation (1+N) + # TODO(justinsb): This is a terrible implementation (1+N) instance_infos = [] for instance_name in self.list_instances(): info = self.get_info(instance_name) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3a58a887e..6cd61a86f 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -73,7 +73,7 @@ class VMOps(object): if not vm_rec["is_a_template"] and not vm_rec["is_control_domain"]: name = vm_rec["name_label"] - #TODO(justinsb): Yuk... + # TODO(justinsb): Yuk... openstack_format = VMHelper.compile_info(vm_rec) state = openstack_format['state'] @@ -932,7 +932,7 @@ class VMOps(object): """ vm_ref = self._get_vm_opaque_ref(instance_or_vm) data = self._session.call_xenapi_request('VM.get_xenstore_data', - (vm_ref, )) + (vm_ref,)) ret = {} if keys is None: keys = data.keys() -- cgit From 52c2bb5e7fadf12aae96d895d374990fd4990e29 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 22 Mar 2011 22:49:22 -0700 Subject: Cleaned up comment about virsh domain.info() return format --- nova/virt/libvirt_conn.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e95bcac39..dfe0bca49 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -60,10 +60,10 @@ from nova import log as logging #from nova import test from nova import utils from nova.auth import manager -from nova.compute import driver from nova.compute import instance_types from nova.compute import power_state from nova.virt import disk +from nova.virt import driver from nova.virt import images libvirt = None @@ -135,8 +135,8 @@ def get_connection(read_only): def _late_load_cheetah(): global Template if Template is None: - t = __import__('Cheetah.Template', globals(), locals(), ['Template'], - -1) + t = __import__('Cheetah.Template', globals(), locals(), + ['Template'], -1) Template = t.Template @@ -238,12 +238,15 @@ class LibvirtConnection(driver.ComputeDriver): for x in self._conn.listDomainsID()] def _map_to_instance_info(self, domain): - # .info() returns a list of: - #state: one of the state values (virDomainState) - #maxMemory: the maximum memory used by the domain - #memory: the current amount of memory used by the domain - #nbVirtCPU: the number of virtual CPU - #cpuTime: the time used by the domain in nanoseconds + """Gets info from a virsh domain object into an InstanceInfo""" + + # domain.info() returns a list of: + # state: one of the state values (virDomainState) + # maxMemory: the maximum memory used by the domain + # memory: the current amount of memory used by the domain + # nbVirtCPU: the number of virtual CPU + # puTime: the time used by the domain in nanoseconds + (state, _max_mem, _mem, _num_cpu, _cpu_time) = domain.info() name = domain.name() -- cgit From 95a32b4ae8d418576799fb9dd5d34e73728d7a1f Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 22 Mar 2011 22:50:45 -0700 Subject: Clarified my "Yuk" comment --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 6cd61a86f..a0c84c803 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -73,7 +73,7 @@ class VMOps(object): if not vm_rec["is_a_template"] and not vm_rec["is_control_domain"]: name = vm_rec["name_label"] - # TODO(justinsb): Yuk... + # TODO(justinsb): This a roundabout way to map the state openstack_format = VMHelper.compile_info(vm_rec) state = openstack_format['state'] -- cgit From b69a63c5d7458610b6e8931b4955c0b5b2b468f5 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 22 Mar 2011 22:58:52 -0700 Subject: Fixed up the new location of driver.py --- nova/virt/driver.py | 5 ++++- nova/virt/fake.py | 2 +- nova/virt/hyperv.py | 2 +- nova/virt/xenapi_conn.py | 2 +- 4 files changed, 7 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index 6c1b97ce9..d01a91b93 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -33,7 +33,10 @@ class InstanceInfo(object): class ComputeDriver(object): - """Base class for compute drivers.""" + """Base class for compute drivers. + + Lots of documentation is currently on fake.py. + """ def init_host(self, host): """Adopt existing VM's running here""" diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 57b02e00b..5b0fe1877 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -27,8 +27,8 @@ semantics of real hypervisor connections. from nova import exception from nova import utils -from nova.compute import driver from nova.compute import power_state +from nova.virt import driver def get_connection(_): diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py index 21e21ec13..bd45dfe0e 100644 --- a/nova/virt/hyperv.py +++ b/nova/virt/hyperv.py @@ -67,8 +67,8 @@ from nova import exception from nova import flags from nova import log as logging from nova.auth import manager -from nova.compute import driver from nova.compute import power_state +from nova.virt import driver from nova.virt import images wmi = None diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 9390db0bb..b5bff6c26 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -69,7 +69,7 @@ from nova import db from nova import utils from nova import flags from nova import log as logging -from nova.compute import driver +from nova.virt import driver from nova.virt.xenapi.vmops import VMOps from nova.virt.xenapi.volumeops import VolumeOps -- cgit From 02db94dc33d72182201fd78651e5e5e82ab411c2 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Wed, 23 Mar 2011 01:22:11 -0700 Subject: Earlier versions of the python libvirt binding had getVersion in the libvirt namespace, not on the connection object. Check both. --- nova/virt/libvirt_conn.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index f264cf619..0fabec4d0 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -981,7 +981,11 @@ class LibvirtConnection(object): """ - return self._conn.getVersion() + # NOTE(justinsb): getVersion moved between libvirt versions + method = getattr(self._conn, 'getVersion', None) # Newer location + if method is None: + method = getattr(libvirt, 'getVersion') # Older location + return method() def get_cpu_info(self): """Get cpuinfo information. -- cgit From f0bb48fc2f2e7d9326c51b4b57e73e0258930909 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 23 Mar 2011 09:34:34 +0000 Subject: removed excess debug line --- nova/virt/xenapi/network_utils.py | 1 - 1 file changed, 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py index 52ad0e1a5..546f6bea9 100644 --- a/nova/virt/xenapi/network_utils.py +++ b/nova/virt/xenapi/network_utils.py @@ -28,7 +28,6 @@ class NetworkHelper(HelperBase): """ The class that wraps the helper methods together. """ - @classmethod def find_network_with_name_label(cls, session, name_label): networks = session.call_xenapi('network.get_by_name_label', name_label) -- cgit From 72c5735e1f77c764fc96e063ea848bac8e1ab810 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 23 Mar 2011 12:39:14 +0000 Subject: Executing parted with sudo in _write_partition --- nova/virt/xenapi/vm_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 7dbca321f..66618963a 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -991,8 +991,8 @@ def _write_partition(virtual_size, dev): def execute(*cmd, **kwargs): return utils.execute(*cmd, **kwargs) - execute('parted', '--script', dest, 'mklabel', 'msdos') - execute('parted', '--script', dest, 'mkpart', 'primary', + execute('sudo', 'parted', '--script', dest, 'mklabel', 'msdos') + execute('sudo', 'parted', '--script', dest, 'mkpart', 'primary', '%ds' % primary_first, '%ds' % primary_last) -- cgit From 3362be7e9f2feda33e14ab4fb7c6f70277df1cf5 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Wed, 23 Mar 2011 12:53:10 +0000 Subject: Checking whether cidr_v6 is not null before populating ipv6 key in network info map (VMOps._get_network_info) --- nova/virt/xenapi/vmops.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 499c6d8a1..b51489ebc 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -723,8 +723,9 @@ class VMOps(object): 'mac': instance.mac_address, 'rxtx_cap': flavor['rxtx_cap'], 'dns': [network['dns']], - 'ips': [ip_dict(ip) for ip in network_IPs], - 'ip6s': [ip6_dict(ip) for ip in network_IPs]} + 'ips': [ip_dict(ip) for ip in network_IPs]} + if network['cidr_v6']: + info['ip6s'] = [ip6_dict(ip) for ip in network_IPs] network_info.append((network, info)) return network_info -- cgit From f5dada1e0193f9fff89735f169aafffbac1cbd4a Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Wed, 23 Mar 2011 19:22:51 +0300 Subject: review comments fixed --- nova/virt/interfaces.template | 4 ++++ nova/virt/libvirt_conn.py | 45 ++++++++++++++++++++----------------------- 2 files changed, 25 insertions(+), 24 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/interfaces.template b/nova/virt/interfaces.template index 7d40a0f69..a946a1000 100644 --- a/nova/virt/interfaces.template +++ b/nova/virt/interfaces.template @@ -7,11 +7,15 @@ iface lo inet loopback #for $ifc in $interfaces auto ${ifc.name} +#if $getVar('ifc.address', None) iface ${ifc.name} inet static address ${ifc.address} netmask ${ifc.netmask} broadcast ${ifc.broadcast} gateway ${ifc.gateway} dns-nameservers ${ifc.dns} +#else +iface ${ifc.name} inet dhcp +#end if #end for diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 579e2960a..7353d1909 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -623,7 +623,7 @@ class LibvirtConnection(object): def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None, network_info=None): - if network_info is None: + if not network_info: network_info = _get_network_info(inst) # syntactic nicety @@ -707,15 +707,16 @@ class LibvirtConnection(object): nets = [] ifc_template = open(FLAGS.injected_network_template).read() ifc_num = -1 - for (network_ref, _m) in network_info: + admin_context = context.get_admin_context() + for (network_ref, _) in network_info: ifc_num += 1 - if network_ref['injected']: - admin_context = context.get_admin_context() + + if not 'injected' in network_ref: + net_info = {'name': 'eth%d' % ifc_num} + else: address = db.instance_get_fixed_address( admin_context, inst['id']) - ra_server = network_ref['ra_server'] - if not ra_server: - ra_server = "fd00::" + ra_server = network_ref.get('ra_server', "fd00::") net_info = {'name': 'eth%d' % ifc_num, 'address': address, 'netmask': network_ref['netmask'], @@ -800,7 +801,7 @@ class LibvirtConnection(object): #TODO(ilyaalekseyev) remove network_info creation code # when multinics will be completed - if network_info is None: + if not network_info: network_info = _get_network_info(instance) nics = [] @@ -809,9 +810,8 @@ class LibvirtConnection(object): network, mapping)) # FIXME(vish): stick this in db - instance_type = instance['instance_type'] - # instance_type = test.INSTANCE_TYPES[instance_type] - instance_type = instance_types.get_instance_type(instance_type) + instance_type_name = instance['instance_type'] + instance_type = instance_types.get_instance_type(instance_type_name) if FLAGS.use_cow_images: driver_type = 'qcow2' @@ -1608,10 +1608,8 @@ class NWFilterFirewall(FirewallDriver): 'nova-base-ipv6', 'nova-allow-dhcp-server'] if FLAGS.use_ipv6: - #ra_server = self._ra_server_for_instance(instance) ra_servers = self._all_ra_servers_for_instance(instance) - #if ra_server: - if len(ra_servers) != 0: + if ra_servers: instance_secgroup_filter_children += ['nova-allow-ra-server'] ctxt = context.get_admin_context() @@ -1729,10 +1727,8 @@ class IptablesFirewallDriver(FirewallDriver): self.iptables.ipv4['filter'].add_chain(chain_name) - ips_v4 = [] - for (_n, mapping) in network_info: - for ip in mapping['ips']: - ips_v4.append(ip['ip']) + ips_v4 = [ip['ip'] for (_, mapping) in network_info + for ip in mapping['ips']] for ipv4_address in ips_v4: self.iptables.ipv4['filter'].add_rule('local', @@ -1741,8 +1737,8 @@ class IptablesFirewallDriver(FirewallDriver): if FLAGS.use_ipv6: self.iptables.ipv6['filter'].add_chain(chain_name) - ips_v6 = [ip['ip'] for ip in mapping['ip6s'] for (_n, mapping) - in network_info] + ips_v6 = [ip['ip'] for (_, mapping) in network_info + for ip in mapping['ip6s']] for ipv6_address in ips_v6: self.iptables.ipv6['filter'].add_rule('local', @@ -1785,14 +1781,14 @@ class IptablesFirewallDriver(FirewallDriver): dhcp_servers = [network['gateway'] for (network, _m) in network_info] for dhcp_server in dhcp_servers: - ipv4_rules += ['-s %s -p udp --sport 67 --dport 68 ' - '-j ACCEPT' % (dhcp_server,)] + ipv4_rules.append('-s %s -p udp --sport 67 --dport 68 ' + '-j ACCEPT' % (dhcp_server,)) #Allow project network traffic if FLAGS.allow_project_net_traffic: cidrs = [network['cidr'] for (network, _m) in network_info] for cidr in cidrs: - ipv4_rules += ['-s %s -j ACCEPT' % (cidr,)] + ipv4_rules.append('-s %s -j ACCEPT' % (cidr,)) # We wrap these in FLAGS.use_ipv6 because they might cause # a DB lookup. The other ones are just list operations, so @@ -1803,7 +1799,8 @@ class IptablesFirewallDriver(FirewallDriver): in network_info] for ra_server in ra_servers: - ipv6_rules += ['-s %s/128 -p icmpv6 -j ACCEPT' % (ra_server,)] + ipv6_rules.append('-s %s/128 -p icmpv6 -j ACCEPT' + % (ra_server,)) #Allow project network traffic if FLAGS.allow_project_net_traffic: -- cgit From a8a345630bd90a74bae00e11dbaf013c60dc7d84 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Wed, 23 Mar 2011 21:44:58 +0300 Subject: pep8 fixed --- nova/virt/libvirt_conn.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 5a5f2b14b..5c9e48864 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -717,7 +717,7 @@ class LibvirtConnection(object): if not 'injected' in network_ref: continue - + address = mapping['ips'][0]['ip'] address_v6 = None if FLAGS.use_ipv6: @@ -1924,4 +1924,3 @@ class IptablesFirewallDriver(FirewallDriver): network = db.network_get_by_instance(context.get_admin_context(), instance['id']) return network['cidr_v6'] - -- cgit From 683fcb5da6e742e2b9f1750939dc6a17776d59de Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Wed, 23 Mar 2011 21:56:24 +0300 Subject: xml template fixed --- nova/virt/libvirt.xml.template | 2 +- nova/virt/libvirt_conn.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index ca03900a8..d74a9e85b 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -82,7 +82,7 @@ ${nic.extra_params} #end if #if $getVar('nic.gateway_v6', False) - + #end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 5c9e48864..bed348332 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -797,7 +797,7 @@ class LibvirtConnection(object): } if gateway_v6: - xml_info['gateway_v6'] = gateway_v6 + "/128" + result['gateway_v6'] = gateway_v6 + "/128" return result -- cgit From 514e748e3000f97a9d1c03ba3b5ab6faff79abfd Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Wed, 23 Mar 2011 22:08:22 +0300 Subject: one more minor fix --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index bed348332..6fb7c06bd 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1814,7 +1814,7 @@ class IptablesFirewallDriver(FirewallDriver): in network_info] for cidrv6 in cidrv6s: - ipv6_rules += ['-s %s -j ACCEPT' % (cidrv6,)] + ipv6_rules.append('-s %s -j ACCEPT' % (cidrv6,)) security_groups = db.security_group_get_by_instance(ctxt, instance['id']) -- cgit From abb764f51385a0b811b23379d78f7db027d4cca5 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 23 Mar 2011 14:41:35 -0500 Subject: Automatically unrescue instances after a given timeout --- nova/virt/libvirt_conn.py | 4 ++ nova/virt/xenapi/vmops.py | 95 +++++++++++++++++++++++++++++++++++------------ nova/virt/xenapi_conn.py | 4 ++ 3 files changed, 79 insertions(+), 24 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e80b9fbdf..07545382d 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -412,6 +412,10 @@ class LibvirtConnection(object): # the normal xml file, we can just call reboot here self.reboot(instance) + @exception.wrap_exception + def poll_rescued_instances(self, timeout): + pass + @exception.wrap_exception def spawn(self, instance): xml = self.to_xml(instance) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 61ff00903..f46ac3b7e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -51,6 +51,7 @@ class VMOps(object): def __init__(self, session): self.XenAPI = session.get_imported_xenapi() self._session = session + self.poll_rescue_last_ran = None VMHelper.XenAPI = self.XenAPI @@ -462,6 +463,10 @@ class VMOps(object): except self.XenAPI.Failure, exc: LOG.exception(exc) + def _shutdown_rescue(self, vm_ref): + """Shutdown a rescue instance""" + self._session.call_xenapi("Async.VM.hard_shutdown", rescue_vm_ref) + def _destroy_vdis(self, instance, vm_ref): """Destroys all VDIs associated with a VM""" instance_id = instance.id @@ -479,6 +484,24 @@ class VMOps(object): except self.XenAPI.Failure, exc: LOG.exception(exc) + def _destroy_rescue_vdis(self, rescue_vm_ref): + """Destroys all VDIs associated with a rescued VM""" + vdi_refs = VMHelper.lookup_vm_vdis(self._session, rescue_vm_ref) + for vdi_ref in vdi_refs: + try: + self._session.call_xenapi("Async.VDI.destroy", vdi_ref) + except self.XenAPI.Failure: + continue + + def _destroy_rescue_vbds(self, rescue_vm_ref): + """Destroys all VBDs tied to a rescue VM""" + vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref) + for vbd_ref in vbd_refs: + _vbd_ref = self._session.get_xenapi().VBD.get_record(vbd_ref) + if _vbd_ref["userdevice"] == "1": + VMHelper.unplug_vbd(self._session, vbd_ref) + VMHelper.destroy_vbd(self._session, vbd_ref) + def _destroy_kernel_ramdisk(self, instance, vm_ref): """ Three situations can occur: @@ -529,6 +552,10 @@ class VMOps(object): LOG.debug(_("Instance %(instance_id)s VM destroyed") % locals()) + def _destroy_rescue(self, vm_ref): + """Destroy a rescue instance""" + self._session.call_xenapi("Async.VM.destroy", rescue_vm_ref) + def destroy(self, instance): """ Destroy VM instance @@ -632,41 +659,61 @@ class VMOps(object): """ rescue_vm_ref = VMHelper.lookup(self._session, - instance.name + "-rescue") + instance.name + "-rescue") if not rescue_vm_ref: raise exception.NotFound(_( "Instance is not in Rescue Mode: %s" % instance.name)) original_vm_ref = self._get_vm_opaque_ref(instance) - vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref) - instance._rescue = False - for vbd_ref in vbd_refs: - _vbd_ref = self._session.get_xenapi().VBD.get_record(vbd_ref) - if _vbd_ref["userdevice"] == "1": - VMHelper.unplug_vbd(self._session, vbd_ref) - VMHelper.destroy_vbd(self._session, vbd_ref) - - task1 = self._session.call_xenapi("Async.VM.hard_shutdown", - rescue_vm_ref) - self._session.wait_for_task(task1, instance.id) - - vdi_refs = VMHelper.lookup_vm_vdis(self._session, rescue_vm_ref) - for vdi_ref in vdi_refs: - try: - task = self._session.call_xenapi('Async.VDI.destroy', vdi_ref) - self._session.wait_for_task(task, instance.id) - except self.XenAPI.Failure: - continue - - task2 = self._session.call_xenapi('Async.VM.destroy', rescue_vm_ref) - self._session.wait_for_task(task2, instance.id) - + self._destroy_rescue_vbds(rescue_vm_ref) + self._shutdown_rescue(rescue_vm_ref) + self._destroy_rescue_vdis(rescue_vm_ref) + self._destroy_rescue(rescue_vm_ref) self._release_bootlock(original_vm_ref) self._start(instance, original_vm_ref) + def poll_rescued_instances(self, timeout): + """Look for expirable rescued instances + - forcibly exit rescue mode for any instances that have been + in rescue mode for >= the provided timeout + """ + last_ran = self.poll_rescue_last_ran + if last_ran: + if not utils.is_then_greater(last_ran, timeout * 60 * 60): + # Do not run. Let's bail. + return + else: + # Update the time tracker and proceed. + self.poll_rescue_last_ran = utils.utcnow() + else: + # We need a base time to start tracking. + self.poll_rescue_last_ran = utils.utcnow() + return + + vms = [] + for instance in self.list_instances(): + if instance.endswith("-rescue"): + vms.append(dict(name=instance, + vm_ref=VMHelper.lookup(self._session, + instance))) + + for vm in vms: + rescue_name = vm["name"] + rescue_vm_ref = vm["vm_ref"] + original_name = vm["name"].split("-rescue", 1)[0] + original_vm_ref = VMHelper.lookup(self._session, original_name) + + self._destroy_rescue_vbds(rescue_vm_ref) + self._shutdown_rescue(rescue_vm_ref) + self._destroy_rescue_vdis(rescue_vm_ref) + self._destroy_rescue(rescue_vm_ref) + self._release_bootlock(original_vm_ref) + self._session.call_xenapi("VM.start", original_vm_ref, False, + False) + def get_info(self, instance): """Return data about VM instance""" vm_ref = self._get_vm_opaque_ref(instance) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index da42a83b6..50aad96b8 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -225,6 +225,10 @@ class XenAPIConnection(object): """Unrescue the specified instance""" self._vmops.unrescue(instance, callback) + def poll_rescued_instances(self, timeout): + """Poll for rescued instances""" + self._vmops.poll_rescued_instances(timeout) + def reset_network(self, instance): """reset networking for specified instance""" self._vmops.reset_network(instance) -- cgit From a291e68fef876080d7984a1d7192e939808596bf Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 23 Mar 2011 14:55:33 -0500 Subject: Fixed some typos --- nova/virt/xenapi/vmops.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index cb36730a0..0a516bd36 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -463,7 +463,7 @@ class VMOps(object): except self.XenAPI.Failure, exc: LOG.exception(exc) - def _shutdown_rescue(self, vm_ref): + def _shutdown_rescue(self, rescue_vm_ref): """Shutdown a rescue instance""" self._session.call_xenapi("Async.VM.hard_shutdown", rescue_vm_ref) @@ -552,7 +552,7 @@ class VMOps(object): LOG.debug(_("Instance %(instance_id)s VM destroyed") % locals()) - def _destroy_rescue(self, vm_ref): + def _destroy_rescue_instance(self, rescue_vm_ref): """Destroy a rescue instance""" self._session.call_xenapi("Async.VM.destroy", rescue_vm_ref) @@ -671,7 +671,7 @@ class VMOps(object): self._destroy_rescue_vbds(rescue_vm_ref) self._shutdown_rescue(rescue_vm_ref) self._destroy_rescue_vdis(rescue_vm_ref) - self._destroy_rescue(rescue_vm_ref) + self._destroy_rescue_instance(rescue_vm_ref) self._release_bootlock(original_vm_ref) self._start(instance, original_vm_ref) @@ -709,7 +709,7 @@ class VMOps(object): self._destroy_rescue_vbds(rescue_vm_ref) self._shutdown_rescue(rescue_vm_ref) self._destroy_rescue_vdis(rescue_vm_ref) - self._destroy_rescue(rescue_vm_ref) + self._destroy_rescue_instance(rescue_vm_ref) self._release_bootlock(original_vm_ref) self._session.call_xenapi("VM.start", original_vm_ref, False, False) -- cgit From 05c4257545fb598222cb472d59d9b8be7ba9535a Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Wed, 23 Mar 2011 13:29:29 -0700 Subject: Give the user a nicer error message if they're using the Lucid libvirt --- nova/virt/libvirt_conn.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0fabec4d0..26d34b367 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -982,10 +982,14 @@ class LibvirtConnection(object): """ # NOTE(justinsb): getVersion moved between libvirt versions - method = getattr(self._conn, 'getVersion', None) # Newer location + # Trying to do be compatible with older versions is a lost cause + # But ... we can at least give the user a nice message + method = getattr(self._conn, 'getVersion', None) if method is None: - method = getattr(libvirt, 'getVersion') # Older location - return method() + raise exception.Error(_("libvirt version is too old" + " (does not support getVersion)")) + + return self._conn.getVersion() def get_cpu_info(self): """Get cpuinfo information. -- cgit From d966b1989224b8ba7bf580a3f3f8fc0f04b9a566 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Wed, 23 Mar 2011 13:34:56 -0700 Subject: Keep the fallback code - we may want to do better version checking in future --- nova/virt/libvirt_conn.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 26d34b367..ba794cfd8 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -988,8 +988,11 @@ class LibvirtConnection(object): if method is None: raise exception.Error(_("libvirt version is too old" " (does not support getVersion)")) + # NOTE(justinsb): If we wanted to get the version, we could: + # method = getattr(libvirt, 'getVersion', None) + # NOTE(justinsb): This would then rely on a proper version check - return self._conn.getVersion() + return method() def get_cpu_info(self): """Get cpuinfo information. -- cgit From 95fa499f1a7718694e37a747a6a5a0e309ce877d Mon Sep 17 00:00:00 2001 From: Eldar Nugaev Date: Thu, 24 Mar 2011 00:36:07 +0300 Subject: migration gateway_v6 to network_info --- nova/virt/libvirt_conn.py | 53 +++++++---------------------------------------- 1 file changed, 8 insertions(+), 45 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 6fb7c06bd..dd2439e42 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -757,7 +757,7 @@ class LibvirtConnection(object): if FLAGS.libvirt_type == 'uml': utils.execute('sudo', 'chown', 'root', basepath('disk')) - def _get_nic_for_xml(self, instance_id, network, mapping): + def _get_nic_for_xml(self, network, mapping): # Assume that the gateway also acts as the dhcp server. dhcp_server = network['gateway'] gateway_v6 = network['gateway_v6'] @@ -802,8 +802,6 @@ class LibvirtConnection(object): return result def to_xml(self, instance, rescue=False, network_info=None): - admin_context = context.get_admin_context() - # TODO(termie): cache? LOG.debug(_('instance %s: starting toXML method'), instance['name']) @@ -814,8 +812,7 @@ class LibvirtConnection(object): nics = [] for (network, mapping) in network_info: - nics.append(self._get_nic_for_xml(instance['id'], - network, + nics.append(self._get_nic_for_xml(network, mapping)) # FIXME(vish): stick this in db instance_type_name = instance['instance_type'] @@ -1392,16 +1389,6 @@ class FirewallDriver(object): """ raise NotImplementedError() - def _gateway_v6_for_instance(self, instance): - network = db.network_get_by_instance(context.get_admin_context(), - instance['id']) - return network['gateway_v6'] - - def _all_gateway_v6_for_instance(self, instance): - networks = db.network_get_all_by_instance(context.get_admin_context(), - instance['id']) - return [network['gateway_v6'] for network in networks] - class NWFilterFirewall(FirewallDriver): """ @@ -1604,6 +1591,8 @@ class NWFilterFirewall(FirewallDriver): it makes sure the filters for the security groups as well as the base filter are all in place. """ + if not network_info: + network_info = _get_network_info(instance) if instance['image_id'] == FLAGS.vpn_image_id: base_filter = 'nova-vpn' else: @@ -1616,7 +1605,8 @@ class NWFilterFirewall(FirewallDriver): 'nova-base-ipv6', 'nova-allow-dhcp-server'] if FLAGS.use_ipv6: - gateways_v6 = self._all_gateway_v6_for_instance(instance) + gateways_v6 = [network['gateway_v6'] for (network, _) in + network_info] if gateways_v6: instance_secgroup_filter_children += ['nova-allow-ra-server'] @@ -1803,7 +1793,8 @@ class IptablesFirewallDriver(FirewallDriver): # they're not worth the clutter. if FLAGS.use_ipv6: # Allow RA responses - gateways_v6 = self._all_gateway_v6_for_instance(instance) + gateways_v6 = [network['gateway_v6'] for (network, _) in + network_info] for gateway_v6 in gateways_v6: ipv6_rules.append( '-s %s/128 -p icmpv6 -j ACCEPT' % (gateway_v6,)) @@ -1896,31 +1887,3 @@ class IptablesFirewallDriver(FirewallDriver): def _instance_chain_name(self, instance): return 'inst-%s' % (instance['id'],) - - def _ip_for_instance(self, instance): - return db.instance_get_fixed_address(context.get_admin_context(), - instance['id']) - - def _ip_for_instance_v6(self, instance): - return db.instance_get_fixed_address_v6(context.get_admin_context(), - instance['id']) - - def _dhcp_server_for_instance(self, instance): - network = db.network_get_by_instance(context.get_admin_context(), - instance['id']) - return network['gateway'] - - def _gateway_v6_for_instance(self, instance): - network = db.network_get_by_instance(context.get_admin_context(), - instance['id']) - return network['gateway_v6'] - - def _project_cidr_for_instance(self, instance): - network = db.network_get_by_instance(context.get_admin_context(), - instance['id']) - return network['cidr'] - - def _project_cidrv6_for_instance(self, instance): - network = db.network_get_by_instance(context.get_admin_context(), - instance['id']) - return network['cidr_v6'] -- cgit From a12b6f0a0808fba5541723a537118447b55b69ad Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 23 Mar 2011 17:15:41 -0500 Subject: Better method name --- nova/virt/xenapi/vmops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 0a516bd36..3f1eceddc 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -682,7 +682,7 @@ class VMOps(object): """ last_ran = self.poll_rescue_last_ran if last_ran: - if not utils.is_then_greater(last_ran, timeout * 60 * 60): + if not utils.is_older_than(last_ran, timeout * 60 * 60): # Do not run. Let's bail. return else: -- cgit From e0289dd26821545a6ef2ca91eb2dba7c11c2cc9f Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Wed, 23 Mar 2011 15:53:46 -0700 Subject: general cleanup, use whitelist for webserver security --- nova/virt/libvirt.xml.template | 2 +- nova/virt/libvirt_conn.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 037cd0902..bcc6b3aed 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -101,7 +101,7 @@ -#if $getVar('vnc_host_iface', False) +#if $getVar('vnc_compute_host_iface', False) #end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 51f263ce9..c3529f512 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -735,7 +735,7 @@ class LibvirtConnection(object): 'driver_type': driver_type} if FLAGS.vnc_enabled: - xml_info['vnc_host_iface'] = FLAGS.vnc_host_iface + xml_info['vnc_compute_host_iface'] = FLAGS.vnc_compute_host_iface if ra_server: xml_info['ra_server'] = ra_server + "/128" if not rescue: -- cgit From e19b12f668fb6cd693df6834f8895fb5487953d7 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 23 Mar 2011 18:34:47 -0500 Subject: Review feedback --- nova/virt/xenapi/vmops.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 3f1eceddc..1f2e10aa6 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -497,8 +497,8 @@ class VMOps(object): """Destroys all VBDs tied to a rescue VM""" vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref) for vbd_ref in vbd_refs: - _vbd_ref = self._session.get_xenapi().VBD.get_record(vbd_ref) - if _vbd_ref["userdevice"] == "1": + vbd_rec = self._session.get_xenapi().VBD.get_record(vbd_ref) + if vbd_rec["userdevice"] == "1": # primary VBD is always 1 VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) @@ -554,6 +554,10 @@ class VMOps(object): def _destroy_rescue_instance(self, rescue_vm_ref): """Destroy a rescue instance""" + self._destroy_rescue_vbds(rescue_vm_ref) + self._shutdown_rescue(rescue_vm_ref) + self._destroy_rescue_vdis(rescue_vm_ref) + self._session.call_xenapi("Async.VM.destroy", rescue_vm_ref) def destroy(self, instance): @@ -668,9 +672,6 @@ class VMOps(object): original_vm_ref = self._get_vm_opaque_ref(instance) instance._rescue = False - self._destroy_rescue_vbds(rescue_vm_ref) - self._shutdown_rescue(rescue_vm_ref) - self._destroy_rescue_vdis(rescue_vm_ref) self._destroy_rescue_instance(rescue_vm_ref) self._release_bootlock(original_vm_ref) self._start(instance, original_vm_ref) @@ -682,7 +683,7 @@ class VMOps(object): """ last_ran = self.poll_rescue_last_ran if last_ran: - if not utils.is_older_than(last_ran, timeout * 60 * 60): + if not utils.is_older_than(last_ran, timeout): # Do not run. Let's bail. return else: @@ -693,23 +694,22 @@ class VMOps(object): self.poll_rescue_last_ran = utils.utcnow() return - vms = [] + rescue_vms = [] for instance in self.list_instances(): if instance.endswith("-rescue"): - vms.append(dict(name=instance, - vm_ref=VMHelper.lookup(self._session, - instance))) + rescue_vms.append(dict(name=instance, + vm_ref=VMHelper.lookup(self._session, + instance))) - for vm in vms: + for vm in rescue_vms: rescue_name = vm["name"] rescue_vm_ref = vm["vm_ref"] + + self._destroy_rescue_instance(rescue_vm_ref) + original_name = vm["name"].split("-rescue", 1)[0] original_vm_ref = VMHelper.lookup(self._session, original_name) - self._destroy_rescue_vbds(rescue_vm_ref) - self._shutdown_rescue(rescue_vm_ref) - self._destroy_rescue_vdis(rescue_vm_ref) - self._destroy_rescue_instance(rescue_vm_ref) self._release_bootlock(original_vm_ref) self._session.call_xenapi("VM.start", original_vm_ref, False, False) -- cgit From 7a93455f41e5198fdce8aa1b3091efd956e1c186 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Wed, 23 Mar 2011 16:49:50 -0700 Subject: Doh! Missed two places which were importing the old driver location --- nova/virt/connection.py | 2 +- nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/connection.py b/nova/virt/connection.py index 4ba31c7a7..af7001715 100644 --- a/nova/virt/connection.py +++ b/nova/virt/connection.py @@ -24,7 +24,7 @@ import sys from nova import flags from nova import log as logging from nova import utils -from nova.compute import driver +from nova.virt import driver from nova.virt import fake from nova.virt import libvirt_conn from nova.virt import xenapi_conn diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 2a9694f45..3fd98be67 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -35,8 +35,8 @@ from nova import exception from nova import utils from nova.auth.manager import AuthManager -from nova.compute import driver from nova.compute import power_state +from nova.virt import driver from nova.virt.xenapi.network_utils import NetworkHelper from nova.virt.xenapi.vm_utils import VMHelper from nova.virt.xenapi.vm_utils import ImageType -- cgit From 3c295817f91eb7c76a64d157ff4a938c85075a36 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Wed, 23 Mar 2011 18:50:30 -0700 Subject: pep8 fixes, backported some important fixes that didn't make it over from my testing system :-( --- nova/virt/driver.py | 9 ++++----- nova/virt/libvirt_conn.py | 2 +- 2 files changed, 5 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index d01a91b93..e82f49ebe 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -28,13 +28,13 @@ from nova.compute import power_state class InstanceInfo(object): def __init__(self, name, state): self.name = name - assert state in power_state.valid_states() + assert state in power_state.valid_states(), "Bad state: %s" % state self.state = state class ComputeDriver(object): """Base class for compute drivers. - + Lots of documentation is currently on fake.py. """ @@ -44,7 +44,7 @@ class ComputeDriver(object): def get_info(self, instance_name): """Get the current status of an instance, by name (not ID!) - + Returns a dict containing: :state: the running state, one of the power_state codes :max_mem: (int) the maximum memory in KBytes allowed @@ -78,7 +78,7 @@ class ComputeDriver(object): def get_console_pool_info(self, console_type): """??? - + Returns a dict containing: :address: ??? :username: ??? @@ -228,4 +228,3 @@ class ComputeDriver(object): def inject_network_info(self, instance): """inject network info for specified instance""" raise NotImplementedError() - diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index e57859f9d..ddc525e06 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -255,7 +255,7 @@ class LibvirtConnection(driver.ComputeDriver): def list_instances_detail(self): infos = [] for domain_id in self._conn.listDomainsID(): - domain = self._conn.lookupById(domain_id) + domain = self._conn.lookupByID(domain_id) info = self._map_to_instance_info(domain) infos.append(info) return infos -- cgit From 52bd70d500e7e82acea55c8d23c3fd1d66555cc0 Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Thu, 24 Mar 2011 02:01:46 +0000 Subject: Addressing Rick Clark's comments. --- nova/virt/disk.py | 9 ++-- nova/virt/xenapi/fake.py | 1 - nova/virt/xenapi/vm_utils.py | 125 +++++++++++++++++++++++-------------------- nova/virt/xenapi/vmops.py | 1 - nova/virt/xenapi_conn.py | 20 +++---- 5 files changed, 82 insertions(+), 74 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index eae667c01..ee6d3e36a 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -166,12 +166,13 @@ def _free_device(device): def get_injectables(inst, template=None, template_data=None): - #load cheetah.template if necessary + # Note(salvatore-orlando): + # it the caller does not provide template object and data + # we will import the Cheetah template module and load the + # data from the file specified by injected_network_template flag if not template: - t = __import__('Cheetah.Template', globals(), locals(), ['Template'], - -1) + from Cheetah import Template as t template = t.Template - #load template file if necessary if not template_data: template_data = open(FLAGS.injected_network_template).read() diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 60db86ecd..18d558058 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -427,7 +427,6 @@ class SessionBase(object): if (field in _db_content[cls][ref]): return _db_content[cls][ref][field] else: - LOG.debug(_('Raising Failure')) raise Failure(['HANDLE_INVALID', cls, ref]) LOG.debug(_('Raising NotImplemented')) diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 7b6f2b5da..d429dae3c 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -683,65 +683,12 @@ class VMHelper(HelperBase): # everything mount_required = False key, net = disk.get_injectables(instance) - if key is not None or net is not None: - mount_required = True - - if mount_required: - - def _mounted_processing(device): - """Callback which runs with the image VDI attached""" + mount_required = key or net + if not mount_required: + return - dev_path = '/dev/' + device + '1' # NB: Partition 1 hardcoded - tmpdir = tempfile.mkdtemp() - try: - # Mount only Linux filesystems, to avoid disturbing - # NTFS images - try: - out, err = utils.execute('sudo', 'mount', - '-t', 'ext2,ext3', - dev_path, tmpdir) - except exception.ProcessExecutionError as e: - err = str(e) - if err: - LOG.info(_('Failed to mount filesystem (expected for ' - 'non-linux instances): %s') % err) - else: - try: - # This try block ensures that the umount occurs - xe_guest_agent_filename = os.path.join( - tmpdir, FLAGS.xenapi_agent_path) - if os.path.isfile(xe_guest_agent_filename): - # The presence of the guest agent - # file indicates that this instance can - # reconfigure the network from xenstore data, - # so manipulation of files in /etc is not - # required - LOG.info(_('XenServer tools installed in this ' - 'image are capable of network injection. ' - 'Networking files will not be' - 'manipulated')) - else: - xe_daemon_filename = os.path.join(tmpdir, - 'usr', 'sbin', 'xe-daemon') - if os.path.isfile(xe_daemon_filename): - LOG.info(_('XenServer tools are present ' - 'in this image but are not capable ' - 'of network injection')) - else: - LOG.info(_('XenServer tools are not ' - 'installed in this image')) - LOG.info(_('Manipulating interface files ' - 'directly')) - disk.inject_data_into_fs(tmpdir, key, net, - utils.execute) - finally: - utils.execute('sudo', 'umount', dev_path) - finally: - # remove temporary directory - os.rmdir(tmpdir) - - with_vdi_attached_here(session, vdi_ref, False, - _mounted_processing) + with_vdi_attached_here(session, vdi_ref, False, + lambda dev: _mounted_processing(dev, key, net)) @classmethod def lookup_kernel_ramdisk(cls, session, vm): @@ -1077,3 +1024,65 @@ def _write_partition(virtual_size, dev): def get_name_label_for_image(image): # TODO(sirp): This should eventually be the URI for the Glance image return _('Glance image %s') % image + + +def _mount_filesystem(dev_path, dir): + """mounts the device specified by dev_path in dir""" + try: + out, err = utils.execute('sudo', 'mount', + '-t', 'ext2,ext3', + dev_path, dir) + except exception.ProcessExecutionError as e: + err = str(e) + return err + + +def _find_guest_agent(base_dir, agent_rel_path): + agent_path = os.path.join(base_dir, agent_rel_path) + if os.path.isfile(agent_path): + # The presence of the guest agent + # file indicates that this instance can + # reconfigure the network from xenstore data, + # so manipulation of files in /etc is not + # required + LOG.info(_('XenServer tools installed in this ' + 'image are capable of network injection. ' + 'Networking files will not be' + 'manipulated')) + return True + xe_daemon_filename = os.path.join(base_dir, + 'usr', 'sbin', 'xe-daemon') + if os.path.isfile(xe_daemon_filename): + LOG.info(_('XenServer tools are present ' + 'in this image but are not capable ' + 'of network injection')) + else: + LOG.info(_('XenServer tools are not ' + 'installed in this image')) + return False + + +def _mounted_processing(device, key, net): + """Callback which runs with the image VDI attached""" + + dev_path = '/dev/' + device + '1' # NB: Partition 1 hardcoded + tmpdir = tempfile.mkdtemp() + try: + # Mount only Linux filesystems, to avoid disturbing NTFS images + err = _mount_filesystem(dev_path, tmpdir) + if not err: + try: + # This try block ensures that the umount occurs + if not _find_guest_agent(tmpdir, FLAGS.xenapi_agent_path): + LOG.info(_('Manipulating interface files ' + 'directly')) + disk.inject_data_into_fs(tmpdir, key, net, + utils.execute) + finally: + utils.execute('sudo', 'umount', dev_path) + else: + LOG.info(_('Failed to mount filesystem (expected for ' + 'non-linux instances): %s') % err) + finally: + # remove temporary directory + os.rmdir(tmpdir) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 59c5f3c13..e3810e218 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -169,7 +169,6 @@ class VMOps(object): def _wait_for_boot(): try: - LOG.debug("ENTERING WAIT FOR BOOT!") state = self.get_info(instance_name)['state'] db.instance_set_state(context.get_admin_context(), instance['id'], state) diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 4f31f1071..7c3d3544f 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -107,17 +107,17 @@ flags.DEFINE_integer('xenapi_vhd_coalesce_max_attempts', 'Max number of times to poll for VHD to coalesce.' ' Used only if connection_type=xenapi.') flags.DEFINE_bool('xenapi_inject_image', - True, - 'Specifies whether an attempt to inject network/key' - ' data into the disk image should be made.' - ' Used only if connection_type=xenapi.') + True, + 'Specifies whether an attempt to inject network/key' + ' data into the disk image should be made.' + ' Used only if connection_type=xenapi.') flags.DEFINE_string('xenapi_agent_path', - 'usr/sbin/xe-update-networking', - 'Specifies the path in which the xenapi guest agent' - ' should be located. If the agent is present,' - ' network configuration if not injected into the image' - ' Used only if connection_type=xenapi.' - ' and xenapi_inject_image=True') + 'usr/sbin/xe-update-networking', + 'Specifies the path in which the xenapi guest agent' + ' should be located. If the agent is present,' + ' network configuration if not injected into the image' + ' Used only if connection_type=xenapi.' + ' and xenapi_inject_image=True') flags.DEFINE_string('xenapi_sr_base_path', '/var/run/sr-mount', 'Base path to the storage repository') -- cgit From 31940b550e49c23ba29c71a0e0593a6d14331516 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Wed, 23 Mar 2011 19:02:20 -0700 Subject: Added revert_resize to base class --- nova/virt/driver.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index e82f49ebe..4c77048be 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -120,6 +120,10 @@ class ComputeDriver(object): def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" raise NotImplementedError() + + def revert_resize(self, instance): + """Reverts a resize, powering back on the instance""" + raise NotImplementedError() def pause(self, instance, callback): """Pause VM instance""" -- cgit From 3cde42aaac50e32f2c8fcd4493c40a2eaf1a0d4d Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Wed, 23 Mar 2011 19:15:41 -0700 Subject: pep8 fix --- nova/virt/driver.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index 4c77048be..0e3a4aa3b 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -120,7 +120,7 @@ class ComputeDriver(object): def finish_resize(self, instance, disk_info): """Completes a resize, turning on the migrated instance""" raise NotImplementedError() - + def revert_resize(self, instance): """Reverts a resize, powering back on the instance""" raise NotImplementedError() -- cgit From 10e61af8a23c126c15fcfcf25156d32facf19ec2 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 23 Mar 2011 22:55:04 -0500 Subject: Added hyperv stub --- nova/virt/hyperv.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py index 29d18dac5..75fed6d4f 100644 --- a/nova/virt/hyperv.py +++ b/nova/virt/hyperv.py @@ -467,3 +467,6 @@ class HyperVConnection(object): if vm is None: raise exception.NotFound('Cannot detach volume from missing %s ' % instance_name) + + def poll_rescued_instances(self, timeout): + pass -- cgit From bebc9504bb34934147705512413267d1ae4af170 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Thu, 24 Mar 2011 04:02:31 -0700 Subject: Fake out network service as well, otherwise we can't terminate the instance in test_servers now that we've started a compute service --- nova/virt/fake.py | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/fake.py b/nova/virt/fake.py index 3a06284a1..505ce0959 100644 --- a/nova/virt/fake.py +++ b/nova/virt/fake.py @@ -26,9 +26,13 @@ semantics of real hypervisor connections. """ from nova import exception +from nova import log as logging from nova.compute import power_state +LOG = logging.getLogger('nova.compute.disk') + + def get_connection(_): # The read_only parameter is ignored. return FakeConnection.instance() @@ -244,6 +248,10 @@ class FakeConnection(object): The work will be done asynchronously. This function returns a task that allows the caller to detect when it is complete. """ + key = instance.name + if not key in self.instances: + LOG.warning("Key '%s' not in instances '%s'" % + (key, self.instances)) del self.instances[instance.name] def attach_volume(self, instance_name, device_path, mountpoint): -- cgit From 1378db7ac86b69b8a966448b63415b2136b6b5bc Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 24 Mar 2011 09:07:57 -0400 Subject: Fix up formatting of libvirt.xml.template --- nova/virt/libvirt.xml.template | 132 ++++++++++++++++++++--------------------- 1 file changed, 66 insertions(+), 66 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 77c1b1997..26f528cb1 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -3,47 +3,47 @@ ${memory_kb} #if $type == 'lxc' - #set $disk_prefix = '' + #set $disk prefix = '' #set $disk_bus = '' exe /sbin/init #else -#if $type == 'uml' - #set $disk_prefix = 'ubd' - #set $disk_bus = 'uml' - uml - /usr/bin/linux - /dev/ubda -#else - #if $type == 'xen' - #set $disk_prefix = 'sd' - #set $disk_bus = 'scsi' - linux - /dev/xvda - #else - #set $disk_prefix = 'vd' - #set $disk_bus = 'virtio' - hvm - #end if - #if $getVar('rescue', False) - ${basepath}/kernel.rescue - ${basepath}/ramdisk.rescue - #else - #if $getVar('kernel', None) - ${kernel} - #if $type == 'xen' - ro - #else - root=/dev/vda console=ttyS0 - #end if - #if $getVar('ramdisk', None) - ${ramdisk} - #end if - #else - - #end if - #end if - #end if + #if $type == 'uml' + #set $disk_prefix = 'ubd' + #set $disk_bus = 'uml' + uml + /usr/bin/linux + /dev/ubda + #else + #if $type == 'xen' + #set $disk_prefix = 'sd' + #set $disk_bus = 'scsi' + linux + /dev/xvda + #else + #set $disk_prefix = 'vd' + #set $disk_bus = 'virtio' + hvm + #end if + #if $getVar('rescue', False) + ${basepath}/kernel.rescue + ${basepath}/ramdisk.rescue + #else + #if $getVar('kernel', None) + ${kernel} + #if $type == 'xen' + ro + #else + root=/dev/vda console=ttyS0 + #end if + #if $getVar('ramdisk', None) + ${ramdisk} + #end if + #else + + #end if + #end if + #end if #end if @@ -52,36 +52,36 @@ ${vcpus} #if $type == 'lxc' - - - - -#else -#if $getVar('rescue', False) - - - - - - - - - - + + + + #else - - - - - - #if $getVar('local', False) - - - - - - #end if - #end if + #if $getVar('rescue', False) + + + + + + + + + + + #else + + + + + + #if $getVar('local', False) + + + + + + #end if +#end if #end if -- cgit From da159d18b56af44f93cbf2c5e80b6aa3c98d5187 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Thu, 24 Mar 2011 09:12:24 -0400 Subject: Dont use popen in dettaching the lxc loop --- nova/virt/disk.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index f6e6795d6..0bdb04cde 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -140,7 +140,8 @@ def destroy_container(target, instance): container_dir = '%s/rootfs' % target utils.execute('sudo', 'umount', container_dir) finally: - for loop in utils.popen('sudo losetup -a').readlines(): + out, err = utils('sudo', 'losetup', '-a') + for loop in out.splitlines(): if instance['name'] in loop: device = loop.split(loop, ':') utils.execute('sudo', 'losetup', '--detach', device) -- cgit From 4e5b511b422501167161c3bbe4dd755c0370c93f Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Thu, 24 Mar 2011 16:53:32 +0300 Subject: couple of bugs fixed --- nova/virt/libvirt_conn.py | 75 ++++++++++++++++++++++++++++++----------------- 1 file changed, 48 insertions(+), 27 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index dd2439e42..bbb5699e9 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -189,8 +189,10 @@ def _get_network_info(instance): 'gateway': network['gateway'], 'mac': instance.mac_address, 'dns': [network['dns']], - 'ips': [ip_dict(ip) for ip in network_ips], - 'ip6s': [ip6_dict(ip) for ip in network_ips]} + 'ips': [ip_dict(ip) for ip in network_ips]} + + if FLAGS.use_ipv6: + mapping['ip6s'] = [ip6_dict(ip) for ip in network_ips] network_info.append((network, mapping)) return network_info @@ -632,6 +634,8 @@ class LibvirtConnection(object): if not network_info: network_info = _get_network_info(inst) + if not suffix: + suffix = '' # syntactic nicety def basepath(fname='', suffix=suffix): return os.path.join(FLAGS.instances_path, @@ -1484,6 +1488,9 @@ class NWFilterFirewall(FirewallDriver): """Set up basic filtering (MAC, IP, and ARP spoofing protection)""" logging.info('called setup_basic_filtering in nwfilter') + if not network_info: + network_info = _get_network_info(instance) + if self.handle_security_groups: # No point in setting up a filter set that we'll be overriding # anyway. @@ -1492,9 +1499,11 @@ class NWFilterFirewall(FirewallDriver): logging.info('ensuring static filters') self._ensure_static_filters() - instance_filter_name = self._instance_filter_name(instance) - self._define_filter(self._filter_container(instance_filter_name, - ['nova-base'])) + for (network, mapping) in network_info: + nic_id = mapping['mac'].replace(':', '') + instance_filter_name = self._instance_filter_name(instance, nic_id) + self._define_filter(self._filter_container(instance_filter_name, + ['nova-base'])) def _ensure_static_filters(self): if self.static_filters_configured: @@ -1598,38 +1607,47 @@ class NWFilterFirewall(FirewallDriver): else: base_filter = 'nova-base' - instance_filter_name = self._instance_filter_name(instance) - instance_secgroup_filter_name = '%s-secgroup' % (instance_filter_name,) - instance_filter_children = [base_filter, instance_secgroup_filter_name] + ctxt = context.get_admin_context() + + instance_secgroup_filter_name = \ + '%s-secgroup' % (self._instance_filter_name(instance)) + #% (instance_filter_name,) + instance_secgroup_filter_children = ['nova-base-ipv4', 'nova-base-ipv6', 'nova-allow-dhcp-server'] - if FLAGS.use_ipv6: - gateways_v6 = [network['gateway_v6'] for (network, _) in - network_info] - if gateways_v6: - instance_secgroup_filter_children += ['nova-allow-ra-server'] - ctxt = context.get_admin_context() - - if FLAGS.allow_project_net_traffic: - instance_filter_children += ['nova-project'] - if FLAGS.use_ipv6: - instance_filter_children += ['nova-project-v6'] - - for security_group in db.security_group_get_by_instance(ctxt, - instance['id']): + for security_group in \ + db.security_group_get_by_instance(ctxt, instance['id']): self.refresh_security_group_rules(security_group['id']) instance_secgroup_filter_children += [('nova-secgroup-%s' % - security_group['id'])] + security_group['id'])] - self._define_filter( + self._define_filter( self._filter_container(instance_secgroup_filter_name, instance_secgroup_filter_children)) - self._define_filter( + for (network, mapping) in network_info: + nic_id = mapping['mac'].replace(':', '') + instance_filter_name = self._instance_filter_name(instance, nic_id) + instance_filter_children = \ + [base_filter, instance_secgroup_filter_name] + + if FLAGS.use_ipv6: + gateway_v6 = network['gateway_v6'] + + if gateway_v6: + instance_secgroup_filter_children += \ + ['nova-allow-ra-server'] + + if FLAGS.allow_project_net_traffic: + instance_filter_children += ['nova-project'] + if FLAGS.use_ipv6: + instance_filter_children += ['nova-project-v6'] + + self._define_filter( self._filter_container(instance_filter_name, instance_filter_children)) @@ -1677,8 +1695,11 @@ class NWFilterFirewall(FirewallDriver): xml += "chain='ipv4'>%s" % rule_xml return xml - def _instance_filter_name(self, instance): - return 'nova-instance-%s' % instance['name'] + def _instance_filter_name(self, instance, nic_id=None): + if not nic_id: + return 'nova-instance-%s' % (instance['name']) + + return 'nova-instance-%s-%s' % (instance['name'], nic_id) class IptablesFirewallDriver(FirewallDriver): -- cgit From fa582b2e10e43bbb81e0e5c3baf4560300711271 Mon Sep 17 00:00:00 2001 From: Eldar Nugaev Date: Thu, 24 Mar 2011 17:24:44 +0300 Subject: pep8 clearing --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index bbb5699e9..181de4540 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -636,6 +636,7 @@ class LibvirtConnection(object): if not suffix: suffix = '' + # syntactic nicety def basepath(fname='', suffix=suffix): return os.path.join(FLAGS.instances_path, @@ -1698,7 +1699,6 @@ class NWFilterFirewall(FirewallDriver): def _instance_filter_name(self, instance, nic_id=None): if not nic_id: return 'nova-instance-%s' % (instance['name']) - return 'nova-instance-%s-%s' % (instance['name'], nic_id) -- cgit From cf70a1a76dfa0456ea6230eaa014fa98e7ddd464 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 24 Mar 2011 10:30:09 -0500 Subject: Small refactor --- nova/virt/xenapi/vmops.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 84cf836ac..6c1f6424a 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -528,7 +528,7 @@ class VMOps(object): vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref) for vbd_ref in vbd_refs: vbd_rec = self._session.get_xenapi().VBD.get_record(vbd_ref) - if vbd_rec["userdevice"] == "1": # primary VBD is always 1 + if vbd_rec.get("userdevice", None) == "1": # VBD is always 1 VMHelper.unplug_vbd(self._session, vbd_ref) VMHelper.destroy_vbd(self._session, vbd_ref) @@ -712,18 +712,18 @@ class VMOps(object): in rescue mode for >= the provided timeout """ last_ran = self.poll_rescue_last_ran - if last_ran: - if not utils.is_older_than(last_ran, timeout): - # Do not run. Let's bail. - return - else: - # Update the time tracker and proceed. - self.poll_rescue_last_ran = utils.utcnow() - else: + if not last_ran: # We need a base time to start tracking. self.poll_rescue_last_ran = utils.utcnow() return + if not utils.is_older_than(last_ran, timeout): + # Do not run. Let's bail. + return + + # Update the time tracker and proceed. + self.poll_rescue_last_ran = utils.utcnow() + rescue_vms = [] for instance in self.list_instances(): if instance.endswith("-rescue"): -- cgit From b7150a461ab2aaee3c0a0f7e2b6588ddd4324b52 Mon Sep 17 00:00:00 2001 From: Armando Migliaccio Date: Thu, 24 Mar 2011 16:38:31 +0000 Subject: Addressed issues raised by Rick Harris' review --- nova/virt/vmwareapi/error_util.py | 8 +- nova/virt/vmwareapi/fake.py | 77 ++++------- nova/virt/vmwareapi/io_util.py | 4 +- nova/virt/vmwareapi/network_utils.py | 227 ++++++++++++++++----------------- nova/virt/vmwareapi/read_write_util.py | 8 +- nova/virt/vmwareapi/vim.py | 4 +- nova/virt/vmwareapi/vim_util.py | 11 +- nova/virt/vmwareapi/vm_util.py | 10 +- nova/virt/vmwareapi/vmops.py | 8 +- nova/virt/vmwareapi_conn.py | 26 +++- 10 files changed, 190 insertions(+), 193 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/error_util.py b/nova/virt/vmwareapi/error_util.py index f14cafed5..53fa8f24d 100644 --- a/nova/virt/vmwareapi/error_util.py +++ b/nova/virt/vmwareapi/error_util.py @@ -41,7 +41,7 @@ class SessionOverLoadException(VimException): class VimAttributeError(VimException): - """VIM Attribute Error.""" + """VI Attribute Error.""" pass @@ -57,15 +57,15 @@ class VimFaultException(Exception): return str(self.exception_obj) -class FaultCheckers: +class FaultCheckers(object): """ Methods for fault checking of SOAP response. Per Method error handlers for which we desire error checking are defined. SOAP faults are embedded in the SOAP messages as properties and not as SOAP faults. """ - @classmethod - def retrieveproperties_fault_checker(self, resp_obj): + @staticmethod + def retrieveproperties_fault_checker(resp_obj): """ Checks the RetrieveProperties response for errors. Certain faults are sent as part of the SOAP body as property of missingSet. diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py index 3afb46590..4bb467fa9 100644 --- a/nova/virt/vmwareapi/fake.py +++ b/nova/virt/vmwareapi/fake.py @@ -68,16 +68,16 @@ def cleanup(): _db_content[c] = {} -def _create_object(table, obj): +def _create_object(table, table_obj): """Create an object in the db.""" - _db_content[table][obj.obj] = obj + _db_content[table][table_obj.obj] = table_obj -def _get_objects(type): +def _get_objects(obj_type): """Get objects of the type.""" lst_objs = [] - for key in _db_content[type]: - lst_objs.append(_db_content[type][key]) + for key in _db_content[obj_type]: + lst_objs.append(_db_content[obj_type][key]) return lst_objs @@ -88,19 +88,13 @@ class Prop(object): self.name = None self.val = None - def setVal(self, val): - self.val = val - - def setName(self, name): - self.name = name - class ManagedObject(object): """Managed Data Object base class.""" def __init__(self, name="ManagedObject", obj_ref=None): """Sets the obj property which acts as a reference to the object.""" - object.__setattr__(self, 'objName', name) + super(ManagedObject, self).__setattr__('objName', name) if obj_ref is None: obj_ref = str(uuid.uuid4()) object.__setattr__(self, 'obj', obj_ref) @@ -127,8 +121,8 @@ class ManagedObject(object): prop.val = val return elem = Prop() - elem.setName(attr) - elem.setVal(val) + elem.name = attr + elem.val = val self.propSet.append(elem) def __getattr__(self, attr): @@ -143,15 +137,7 @@ class ManagedObject(object): class DataObject(object): """Data object base class.""" - - def __init__(self): - pass - - def __getattr__(self, attr): - return object.__getattribute__(self, attr) - - def __setattr__(self, attr, value): - object.__setattr__(self, attr, value) + pass class VirtualDisk(DataObject): @@ -160,30 +146,24 @@ class VirtualDisk(DataObject): __class__.__name__ to 'VirtualDisk'. Refer place where __class__.__name__ is used in the code. """ - - def __init__(self): - DataObject.__init__(self) + pass class VirtualDiskFlatVer2BackingInfo(DataObject): """VirtualDiskFlatVer2BackingInfo class.""" - - def __init__(self): - DataObject.__init__(self) + pass class VirtualLsiLogicController(DataObject): """VirtualLsiLogicController class.""" - - def __init__(self): - DataObject.__init__(self) + pass class VirtualMachine(ManagedObject): """Virtual Machine class.""" def __init__(self, **kwargs): - ManagedObject.__init__(self, "VirtualMachine") + super(VirtualMachine, self).__init__("VirtualMachine") self.set("name", kwargs.get("name")) self.set("runtime.connectionState", kwargs.get("conn_state", "connected")) @@ -224,7 +204,7 @@ class VirtualMachine(ManagedObject): controller.key = controller_key self.set("config.hardware.device", [disk, controller]) - except Exception: + except AttributeError: # Case of Reconfig of VM to set extra params self.set("config.extraConfig", val.extraConfig) @@ -233,7 +213,7 @@ class Network(ManagedObject): """Network class.""" def __init__(self): - ManagedObject.__init__(self, "Network") + super(Network, self).__init__("Network") self.set("summary.name", "vmnet0") @@ -241,7 +221,7 @@ class ResourcePool(ManagedObject): """Resource Pool class.""" def __init__(self): - ManagedObject.__init__(self, "ResourcePool") + super(ResourcePool, self).__init__("ResourcePool") self.set("name", "ResPool") @@ -249,7 +229,7 @@ class Datastore(ManagedObject): """Datastore class.""" def __init__(self): - ManagedObject.__init__(self, "Datastore") + super(Datastore, self).__init__("Datastore") self.set("summary.type", "VMFS") self.set("summary.name", "fake-ds") @@ -258,7 +238,7 @@ class HostNetworkSystem(ManagedObject): """HostNetworkSystem class.""" def __init__(self): - ManagedObject.__init__(self, "HostNetworkSystem") + super(HostNetworkSystem, self).__init__("HostNetworkSystem") self.set("name", "networkSystem") pnic_do = DataObject() @@ -274,7 +254,7 @@ class HostSystem(ManagedObject): """Host System class.""" def __init__(self): - ManagedObject.__init__(self, "HostSystem") + super(HostSystem, self).__init__("HostSystem") self.set("name", "ha-host") if _db_content.get("HostNetworkSystem", None) is None: create_host_network_system() @@ -341,7 +321,7 @@ class Datacenter(ManagedObject): """Datacenter class.""" def __init__(self): - ManagedObject.__init__(self, "Datacenter") + super(Datacenter, self).__init__("Datacenter") self.set("name", "ha-datacenter") self.set("vmFolder", "vm_folder_ref") if _db_content.get("Network", None) is None: @@ -356,7 +336,7 @@ class Task(ManagedObject): """Task class.""" def __init__(self, task_name, state="running"): - ManagedObject.__init__(self, "Task") + super(Task, self).__init__("Task") info = DataObject info.name = task_name info.state = state @@ -406,7 +386,7 @@ def _add_file(file_path): def _remove_file(file_path): """Removes a file reference from the db.""" - if _db_content.get("files", None) is None: + if _db_content.get("files") is None: raise exception.NotFound(_("No files have been added yet")) # Check if the remove is for a single file object or for a folder if file_path.find(".vmdk") != -1: @@ -418,10 +398,9 @@ def _remove_file(file_path): # Removes the files in the folder and the folder too from the db for file in _db_content.get("files"): if file.find(file_path) != -1: - try: - _db_content.get("files").remove(file) - except Exception: - pass + lst_files = _db_content.get("files") + if lst_files and lst_files.count(file): + lst_files.remove(file) def fake_fetch_image(image, instance, **kwargs): @@ -457,9 +436,6 @@ def _get_vm_mdo(vm_ref): class FakeFactory(object): """Fake factory class for the suds client.""" - def __init__(self): - pass - def create(self, obj_name): """Creates a namespace object.""" return DataObject() @@ -661,7 +637,8 @@ class FakeVim(object): for prop in properties: temp_mdo.set(prop, mdo.get(prop)) lst_ret_objs.append(temp_mdo) - except Exception: + except Exception, exc: + LOG.exception(exc) continue return lst_ret_objs diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py index 7f321c1e7..2ec773b7b 100644 --- a/nova/virt/vmwareapi/io_util.py +++ b/nova/virt/vmwareapi/io_util.py @@ -82,8 +82,8 @@ class GlanceWriteThread(object): """Function to do the image data transfer through an update and thereon checks if the state is 'active'.""" self.glance_client.update_image(self.image_id, - image_meta=self.image_meta, - image_data=self.input) + image_meta=self.image_meta, + image_data=self.input) self._running = True while self._running: try: diff --git a/nova/virt/vmwareapi/network_utils.py b/nova/virt/vmwareapi/network_utils.py index 9232adab6..e77842535 100644 --- a/nova/virt/vmwareapi/network_utils.py +++ b/nova/virt/vmwareapi/network_utils.py @@ -28,123 +28,122 @@ from nova.virt.vmwareapi import vm_util LOG = logging.getLogger("nova.virt.vmwareapi.network_utils") -class NetworkHelper: - - @classmethod - def get_network_with_the_name(cls, session, network_name="vmnet0"): - """ - Gets reference to the network whose name is passed as the - argument. - """ - hostsystems = session._call_method(vim_util, "get_objects", - "HostSystem", ["network"]) - vm_networks_ret = hostsystems[0].propSet[0].val - # Meaning there are no networks on the host. suds responds with a "" - # in the parent property field rather than a [] in the - # ManagedObjectRefernce property field of the parent - if not vm_networks_ret: - return None - vm_networks = vm_networks_ret.ManagedObjectReference - networks = session._call_method(vim_util, - "get_properties_for_a_collection_of_objects", - "Network", vm_networks, ["summary.name"]) - for network in networks: - if network.propSet[0].val == network_name: - return network.obj +def get_network_with_the_name(session, network_name="vmnet0"): + """ + Gets reference to the network whose name is passed as the + argument. + """ + hostsystems = session._call_method(vim_util, "get_objects", + "HostSystem", ["network"]) + vm_networks_ret = hostsystems[0].propSet[0].val + # Meaning there are no networks on the host. suds responds with a "" + # in the parent property field rather than a [] in the + # ManagedObjectRefernce property field of the parent + if not vm_networks_ret: return None + vm_networks = vm_networks_ret.ManagedObjectReference + networks = session._call_method(vim_util, + "get_properties_for_a_collection_of_objects", + "Network", vm_networks, ["summary.name"]) + for network in networks: + if network.propSet[0].val == network_name: + return network.obj + return None + + +def get_vswitch_for_vlan_interface(session, vlan_interface): + """ + Gets the vswitch associated with the physical network adapter + with the name supplied. + """ + # Get the list of vSwicthes on the Host System + host_mor = session._call_method(vim_util, "get_objects", + "HostSystem")[0].obj + vswitches_ret = session._call_method(vim_util, + "get_dynamic_property", host_mor, + "HostSystem", "config.network.vswitch") + # Meaning there are no vSwitches on the host. Shouldn't be the case, + # but just doing code check + if not vswitches_ret: + return + vswitches = vswitches_ret.HostVirtualSwitch + # Get the vSwitch associated with the network adapter + for elem in vswitches: + try: + for nic_elem in elem.pnic: + if str(nic_elem).split('-')[-1].find(vlan_interface) != -1: + return elem.name + # Catching Attribute error as a vSwitch may not be associated with a + # physical NIC. + except AttributeError: + pass - @classmethod - def get_vswitch_for_vlan_interface(cls, session, vlan_interface): - """ - Gets the vswitch associated with the physical network adapter - with the name supplied. - """ - # Get the list of vSwicthes on the Host System - host_mor = session._call_method(vim_util, "get_objects", - "HostSystem")[0].obj - vswitches_ret = session._call_method(vim_util, - "get_dynamic_property", host_mor, - "HostSystem", "config.network.vswitch") - # Meaning there are no vSwitches on the host. Shouldn't be the case, - # but just doing code check - if not vswitches_ret: - return - vswitches = vswitches_ret.HostVirtualSwitch - # Get the vSwitch associated with the network adapter - for elem in vswitches: - try: - for nic_elem in elem.pnic: - if str(nic_elem).split('-')[-1].find(vlan_interface) != -1: - return elem.name - except Exception: - pass - @classmethod - def check_if_vlan_interface_exists(cls, session, vlan_interface): - """Checks if the vlan_inteface exists on the esx host.""" - host_net_system_mor = session._call_method(vim_util, "get_objects", - "HostSystem", ["configManager.networkSystem"])[0].propSet[0].val - physical_nics_ret = session._call_method(vim_util, - "get_dynamic_property", host_net_system_mor, - "HostNetworkSystem", "networkInfo.pnic") - # Meaning there are no physical nics on the host - if not physical_nics_ret: - return False - physical_nics = physical_nics_ret.PhysicalNic - for pnic in physical_nics: - if vlan_interface == pnic.device: - return True +def check_if_vlan_interface_exists(session, vlan_interface): + """Checks if the vlan_inteface exists on the esx host.""" + host_net_system_mor = session._call_method(vim_util, "get_objects", + "HostSystem", ["configManager.networkSystem"])[0].propSet[0].val + physical_nics_ret = session._call_method(vim_util, + "get_dynamic_property", host_net_system_mor, + "HostNetworkSystem", "networkInfo.pnic") + # Meaning there are no physical nics on the host + if not physical_nics_ret: return False + physical_nics = physical_nics_ret.PhysicalNic + for pnic in physical_nics: + if vlan_interface == pnic.device: + return True + return False - @classmethod - def get_vlanid_and_vswitch_for_portgroup(cls, session, pg_name): - """Get the vlan id and vswicth associated with the port group.""" - host_mor = session._call_method(vim_util, "get_objects", - "HostSystem")[0].obj - port_grps_on_host_ret = session._call_method(vim_util, - "get_dynamic_property", host_mor, - "HostSystem", "config.network.portgroup") - if not port_grps_on_host_ret: - excep = ("ESX SOAP server returned an empty port group " - "for the host system in its response") - LOG.exception(excep) - raise exception.Error(_(excep)) - port_grps_on_host = port_grps_on_host_ret.HostPortGroup - for p_gp in port_grps_on_host: - if p_gp.spec.name == pg_name: - p_grp_vswitch_name = p_gp.vswitch.split("-")[-1] - return p_gp.spec.vlanId, p_grp_vswitch_name - @classmethod - def create_port_group(cls, session, pg_name, vswitch_name, vlan_id=0): - """ - Creates a port group on the host system with the vlan tags - supplied. VLAN id 0 means no vlan id association. - """ - client_factory = session._get_vim().client.factory - add_prt_grp_spec = vm_util.get_add_vswitch_port_group_spec( - client_factory, - vswitch_name, - pg_name, - vlan_id) - host_mor = session._call_method(vim_util, "get_objects", - "HostSystem")[0].obj - network_system_mor = session._call_method(vim_util, - "get_dynamic_property", host_mor, - "HostSystem", "configManager.networkSystem") - LOG.debug(_("Creating Port Group with name %s on " - "the ESX host") % pg_name) - try: - session._call_method(session._get_vim(), - "AddPortGroup", network_system_mor, - portgrp=add_prt_grp_spec) - except error_util.VimFaultException, exc: - # There can be a race condition when two instances try - # adding port groups at the same time. One succeeds, then - # the other one will get an exception. Since we are - # concerned with the port group being created, which is done - # by the other call, we can ignore the exception. - if error_util.FAULT_ALREADY_EXISTS not in exc.fault_list: - raise exception.Error(exc) - LOG.debug(_("Created Port Group with name %s on " - "the ESX host") % pg_name) +def get_vlanid_and_vswitch_for_portgroup(session, pg_name): + """Get the vlan id and vswicth associated with the port group.""" + host_mor = session._call_method(vim_util, "get_objects", + "HostSystem")[0].obj + port_grps_on_host_ret = session._call_method(vim_util, + "get_dynamic_property", host_mor, + "HostSystem", "config.network.portgroup") + if not port_grps_on_host_ret: + excep = ("ESX SOAP server returned an empty port group " + "for the host system in its response") + LOG.exception(excep) + raise exception.Error(_(excep)) + port_grps_on_host = port_grps_on_host_ret.HostPortGroup + for p_gp in port_grps_on_host: + if p_gp.spec.name == pg_name: + p_grp_vswitch_name = p_gp.vswitch.split("-")[-1] + return p_gp.spec.vlanId, p_grp_vswitch_name + + +def create_port_group(session, pg_name, vswitch_name, vlan_id=0): + """ + Creates a port group on the host system with the vlan tags + supplied. VLAN id 0 means no vlan id association. + """ + client_factory = session._get_vim().client.factory + add_prt_grp_spec = vm_util.get_add_vswitch_port_group_spec( + client_factory, + vswitch_name, + pg_name, + vlan_id) + host_mor = session._call_method(vim_util, "get_objects", + "HostSystem")[0].obj + network_system_mor = session._call_method(vim_util, + "get_dynamic_property", host_mor, + "HostSystem", "configManager.networkSystem") + LOG.debug(_("Creating Port Group with name %s on " + "the ESX host") % pg_name) + try: + session._call_method(session._get_vim(), + "AddPortGroup", network_system_mor, + portgrp=add_prt_grp_spec) + except error_util.VimFaultException, exc: + # There can be a race condition when two instances try + # adding port groups at the same time. One succeeds, then + # the other one will get an exception. Since we are + # concerned with the port group being created, which is done + # by the other call, we can ignore the exception. + if error_util.FAULT_ALREADY_EXISTS not in exc.fault_list: + raise exception.Error(exc) + LOG.debug(_("Created Port Group with name %s on " + "the ESX host") % pg_name) diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py index 237fd44dc..84f4942eb 100644 --- a/nova/virt/vmwareapi/read_write_util.py +++ b/nova/virt/vmwareapi/read_write_util.py @@ -15,7 +15,7 @@ # License for the specific language governing permissions and limitations # under the License. -"""Classes to handle image files. +"""Classes to handle image files Collection of classes to handle image upload/download to/from Image service (like Glance image storage and retrieval service) from/to ESX/ESXi server. @@ -43,7 +43,7 @@ USER_AGENT = "OpenStack-ESX-Adapter" try: READ_CHUNKSIZE = client.BaseClient.CHUNKSIZE -except: +except AttributeError: READ_CHUNKSIZE = 65536 @@ -91,8 +91,8 @@ class VMwareHTTPFile(object): """Close the file handle.""" try: self.file_handle.close() - except Exception: - pass + except Exception, exc: + LOG.exception(exc) def __del__(self): """Close the file handle on garbage collection.""" diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index 61a0dd2b3..ba14f1512 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -16,7 +16,7 @@ # under the License. """ -Classes that facilitate SOAP calls for VMware VI API. +Classes for making VMware VI SOAP calls. """ import httplib @@ -80,7 +80,7 @@ class Vim: wsdl_url = FLAGS.vmwareapi_wsdl_loc if wsdl_url is None: raise Exception(_("Must specify vmwareapi_wsdl_loc")) - # Use this when VMware fixes their faulty wsdl + # TODO(sateesh): Use this when VMware fixes their faulty wsdl #wsdl_url = '%s://%s/sdk/vimService.wsdl' % (self._protocol, # self._host_name) url = '%s://%s/sdk' % (self._protocol, self._host_name) diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py index a0088cb6d..11214231c 100644 --- a/nova/virt/vmwareapi/vim_util.py +++ b/nova/virt/vmwareapi/vim_util.py @@ -27,11 +27,12 @@ def build_selection_spec(client_factory, name): return sel_spec -def build_traversal_spec(client_factory, name, type, path, skip, select_set): +def build_traversal_spec(client_factory, name, spec_type, path, skip, + select_set): """Builds the traversal spec object.""" traversal_spec = client_factory.create('ns0:TraversalSpec') traversal_spec.name = name - traversal_spec.type = type + traversal_spec.type = spec_type traversal_spec.path = path traversal_spec.skip = skip traversal_spec.selectSet = select_set @@ -131,7 +132,7 @@ def get_object_properties(vim, collector, mobj, type, properties): usecoll = vim.get_service_content().propertyCollector property_filter_spec = client_factory.create('ns0:PropertyFilterSpec') property_spec = client_factory.create('ns0:PropertySpec') - property_spec.all = (properties == None or len(properties) == 0) + property_spec.all = (properties is None or len(properties) == 0) property_spec.pathSet = properties property_spec.type = type object_spec = client_factory.create('ns0:ObjectSpec') @@ -170,10 +171,10 @@ def get_objects(vim, type, properties_to_collect=["name"], all=False): specSet=[property_filter_spec]) -def get_prop_spec(client_factory, type, properties): +def get_prop_spec(client_factory, spec_type, properties): """Builds the Property Spec Object.""" prop_spec = client_factory.create('ns0:PropertySpec') - prop_spec.type = type + prop_spec.type = spec_type prop_spec.pathSet = properties return prop_spec diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py index f2ef8d2d7..a2fa7600c 100644 --- a/nova/virt/vmwareapi/vm_util.py +++ b/nova/virt/vmwareapi/vm_util.py @@ -126,8 +126,8 @@ def create_network_spec(client_factory, network_name, mac_address): return network_spec -def get_vmdk_attach_config_spec(client_factory, - disksize, file_path, adapter_type="lsiLogic"): +def get_vmdk_attach_config_spec(client_factory, disksize, file_path, + adapter_type="lsiLogic"): """Builds the vmdk attach config spec.""" config_spec = client_factory.create('ns0:VirtualMachineConfigSpec') @@ -198,8 +198,8 @@ def get_vmdk_create_spec(client_factory, size_in_kb, adapter_type="lsiLogic"): return create_vmdk_spec -def create_virtual_disk_spec(client_factory, - disksize, controller_key, file_path=None): +def create_virtual_disk_spec(client_factory, disksize, controller_key, + file_path=None): """ Builds spec for the creation of a new/ attaching of an already existing Virtual Disk to the VM. @@ -288,7 +288,7 @@ def get_machine_id_change_spec(client_factory, mac, ip_addr, netmask, gateway): def get_add_vswitch_port_group_spec(client_factory, vswitch_name, - port_group_name, vlan_id): + port_group_name, vlan_id): """Builds the virtual switch port group add spec.""" vswitch_port_group_spec = client_factory.create('ns0:HostPortGroupSpec') vswitch_port_group_spec.name = port_group_name diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py index e09b89e39..cf6c88bbd 100644 --- a/nova/virt/vmwareapi/vmops.py +++ b/nova/virt/vmwareapi/vmops.py @@ -35,7 +35,7 @@ from nova.compute import power_state from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi import vm_util from nova.virt.vmwareapi import vmware_images -from nova.virt.vmwareapi.network_utils import NetworkHelper +from nova.virt.vmwareapi import network_utils FLAGS = flags.FLAGS LOG = logging.getLogger("nova.virt.vmwareapi.vmops") @@ -113,7 +113,7 @@ class VMWareVMOps(object): def _check_if_network_bridge_exists(): network_ref = \ - NetworkHelper.get_network_with_the_name(self._session, + network_utils.get_network_with_the_name(self._session, net_name) if network_ref is None: raise exception.NotFound(_("Network with the name '%s' doesn't" @@ -590,8 +590,8 @@ class VMWareVMOps(object): "got this exception while deleting" " the VM contents from the disk: %s") % str(excep)) - except Exception, e: - LOG.exception(e) + except Exception, exc: + LOG.exception(exc) def pause(self, instance, callback): """Pause a VM instance.""" diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index 414b8731d..87c3fa299 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -229,7 +229,12 @@ class VMWareAPISession(object): self.vim.get_service_content().sessionManager, sessionId=[self._session_id]) except Exception, excep: - LOG.exception(excep) + # This exception is something we can live with. It is + # just an extra caution on our side. The session may + # have been cleared. We could have made a call to + # SessionIsActive, but that is an overhead because we + # anyway would have to call TerminateSession. + LOG.debug(excep) self._session_id = session.key return except Exception, excep: @@ -243,8 +248,10 @@ class VMWareAPISession(object): # ESX host try: self.vim.Logout(self.vim.get_service_content().sessionManager) - except Exception: - pass + except Exception, excep: + # It is just cautionary on our part to do a logout in del just + # to ensure that the session is not left active. + LOG.debug(excep) def _is_vim_object(self, module): """Check if the module is a VIM Object instance.""" @@ -258,6 +265,7 @@ class VMWareAPISession(object): args = list(args) retry_count = 0 exc = None + last_fault_list = [] while True: try: if not self._is_vim_object(module): @@ -279,6 +287,18 @@ class VMWareAPISession(object): # and then proceeding ahead with the call. exc = excep if error_util.FAULT_NOT_AUTHENTICATED in excep.fault_list: + # Because of the idle session returning an empty + # RetrievePropertiesResponse and also the same is returned + # when there is say empty answer to the query for + # VMs on the host ( as in no VMs on the host), we have no + # way to differentiate. + # So if the previous response was also am empty response + # and after creating a new session, we get the same empty + # response, then we are sure of the response being supposed + # to be empty. + if error_util.FAULT_NOT_AUTHENTICATED in last_fault_list: + return [] + last_fault_list = excep.fault_list self._create_session() else: # No re-trying for errors for API call has gone through -- cgit From c3b98443263de944aa54ae4948330b6cfb9a02a6 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Thu, 24 Mar 2011 23:00:16 +0300 Subject: style and spacing fixed --- nova/virt/libvirt_conn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 0211cb4d8..f41f4df5e 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -154,7 +154,7 @@ def _get_ip_version(cidr): def _get_network_info(instance): - #TODO(ilyaalekseyev) If we will keep this function + # TODO(adiantum) If we will keep this function # we should cache network_info admin_context = context.get_admin_context() @@ -837,7 +837,7 @@ class LibvirtConnection(driver.ComputeDriver): # TODO(termie): cache? LOG.debug(_('instance %s: starting toXML method'), instance['name']) - #TODO(ilyaalekseyev) remove network_info creation code + # TODO(adiantum) remove network_info creation code # when multinics will be completed if not network_info: network_info = _get_network_info(instance) -- cgit From 3426a9296c6f7d249a9c57ba9e614045ffe2f3c7 Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Thu, 24 Mar 2011 16:11:48 -0500 Subject: Review feedback --- nova/virt/xenapi/vmops.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 83d5e8310..419b9ad90 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -684,7 +684,7 @@ class VMOps(object): """ rescue_vm_ref = VMHelper.lookup(self._session, - str(instance.name) + "-rescue") + "%s-rescue" % instance.name) if rescue_vm_ref: raise RuntimeError(_( "Instance is already in Rescue Mode: %s" % instance.name)) @@ -712,7 +712,7 @@ class VMOps(object): """ rescue_vm_ref = VMHelper.lookup(self._session, - str(instance.name) + "-rescue") + "%s-rescue" % instance.name) if not rescue_vm_ref: raise exception.NotFound(_( -- cgit From 08d40029973d9ca97477393531296502a407debe Mon Sep 17 00:00:00 2001 From: Salvatore Orlando Date: Thu, 24 Mar 2011 22:39:39 +0000 Subject: Addressing Trey's comments. Removed disk_get_injectables, using _get_network_info's return value. --- nova/virt/disk.py | 37 --------------------------------- nova/virt/libvirt_conn.py | 31 +++++++++++++++++++++++++++- nova/virt/xenapi/vm_utils.py | 49 +++++++++++++++++++++++++++++++++++++++++--- nova/virt/xenapi/vmops.py | 10 +++++---- nova/virt/xenapi_conn.py | 2 +- 5 files changed, 83 insertions(+), 46 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index ee6d3e36a..25e4f54a9 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -165,43 +165,6 @@ def _free_device(device): _DEVICES.append(device) -def get_injectables(inst, template=None, template_data=None): - # Note(salvatore-orlando): - # it the caller does not provide template object and data - # we will import the Cheetah template module and load the - # data from the file specified by injected_network_template flag - if not template: - from Cheetah import Template as t - template = t.Template - if not template_data: - template_data = open(FLAGS.injected_network_template).read() - - key = str(inst['key_data']) - net = None - network_ref = db.network_get_by_instance(context.get_admin_context(), - inst['id']) - if network_ref['injected']: - admin_context = context.get_admin_context() - address = db.instance_get_fixed_address(admin_context, inst['id']) - address_v6 = None - if FLAGS.use_ipv6: - address_v6 = db.instance_get_fixed_address_v6(admin_context, - inst['id']) - interfaces_info = {'address': address, - 'netmask': network_ref['netmask'], - 'gateway': network_ref['gateway'], - 'broadcast': network_ref['broadcast'], - 'dns': network_ref['dns'], - 'address_v6': address_v6, - 'gateway_v6': network_ref['gateway_v6'], - 'netmask_v6': network_ref['netmask_v6'], - 'use_ipv6': FLAGS.use_ipv6} - net = str(template(template_data, - searchList=[interfaces_info])) - - return key, net - - def inject_data_into_fs(fs, key, net, execute): """Injects data into a filesystem already mounted by the caller. Virt connections can call this directly if they mount their fs diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4b855f5de..f6a51fc62 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -681,7 +681,36 @@ class LibvirtConnection(driver.ComputeDriver): if not inst['kernel_id']: target_partition = "1" - key, net = disk.get_injectables(inst, Template, self.interfaces_xml) + key = str(inst['key_data']) + net = None + + nets = [] + ifc_template = open(FLAGS.injected_network_template).read() + ifc_num = -1 + admin_context = context.get_admin_context() + for (network_ref, mapping) in network_info: + ifc_num += 1 + + if not 'injected' in network_ref: + continue + + address = mapping['ips'][0]['ip'] + address_v6 = None + if FLAGS.use_ipv6: + address_v6 = mapping['ip6s'][0]['ip'] + net_info = {'name': 'eth%d' % ifc_num, + 'address': address, + 'netmask': network_ref['netmask'], + 'gateway': network_ref['gateway'], + 'broadcast': network_ref['broadcast'], + 'dns': network_ref['dns'], + 'address_v6': address_v6, + 'gateway_v6': network_ref['gateway_v6'], + 'netmask_v6': network_ref['netmask_v6'], + 'use_ipv6': FLAGS.use_ipv6} + nets.append(net_info) + + net = str(Template(ifc_template, searchList=[{'interfaces': nets}])) if key or net: inst_name = inst['name'] diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index d429dae3c..5f66c4237 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -674,7 +674,7 @@ class VMHelper(HelperBase): return None @classmethod - def preconfigure_instance(cls, session, instance, vdi_ref): + def preconfigure_instance(cls, session, instance, vdi_ref, network_info): """Makes alterations to the image before launching as part of spawn. """ @@ -682,11 +682,11 @@ class VMHelper(HelperBase): # if at all, so determine whether it's required first, and then do # everything mount_required = False - key, net = disk.get_injectables(instance) + key, net = _prepare_injectables(instance, network_info) mount_required = key or net if not mount_required: return - + with_vdi_attached_here(session, vdi_ref, False, lambda dev: _mounted_processing(dev, key, net)) @@ -1038,6 +1038,10 @@ def _mount_filesystem(dev_path, dir): def _find_guest_agent(base_dir, agent_rel_path): + """ + tries to locate a guest agent at the path + specificed by agent_rel_path + """ agent_path = os.path.join(base_dir, agent_rel_path) if os.path.isfile(agent_path): # The presence of the guest agent @@ -1086,3 +1090,42 @@ def _mounted_processing(device, key, net): finally: # remove temporary directory os.rmdir(tmpdir) + + +def _prepare_injectables(inst, networks_info): + """ + prepares the ssh key and the network configuration file to be + injected into the disk image + """ + #do the import here - Cheetah.Template will be loaded + #only if injection is performed + from Cheetah import Template as t + template = t.Template + template_data = open(FLAGS.injected_network_template).read() + + key = str(inst['key_data']) + net = None + #fetch info only for the 1st network + if len(networks_info) > 0: + network_info = networks_info[0][1] + if network_info: + #remap data in network_info onto keys for template + ip_v4 = ip_v6 = None + if len(network_info['ips']) > 0: + ip_v4 = network_info['ips'][0] + if len(network_info['ip6s']) > 0: + ip_v6 = network_info['ip6s'][0] + if len(network_info['dns']) > 0: + dns = network_info['dns'][0] + interfaces_info = {'address': ip_v4 and ip_v4['ip'] or '', + 'netmask': ip_v4 and ip_v4['netmask'] or '', + 'gateway': network_info['gateway'], + 'broadcast': network_info['broadcast'], + 'dns': dns, + 'address_v6': ip_v6 and ip_v6['ip'] or '', + 'netmask_v6': ip_v6 and ip_v6['netmask'] or '', + 'gateway_v6': ip_v6 and ip_v6['gateway'] or '', + 'use_ipv6': FLAGS.use_ipv6} + net = str(template(template_data, + searchList=[interfaces_info])) + return key, net \ No newline at end of file diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 8e5302766..b33b5902c 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -161,14 +161,16 @@ class VMOps(object): VMHelper.create_vbd(session=self._session, vm_ref=vm_ref, vdi_ref=vdi_ref, userdevice=0, bootable=True) - # Alter the image before VM start for, e.g. network injection - if FLAGS.xenapi_inject_image: - VMHelper.preconfigure_instance(self._session, instance, vdi_ref) - # TODO(tr3buchet) - check to make sure we have network info, otherwise # create it now. This goes away once nova-multi-nic hits. if network_info is None: network_info = self._get_network_info(instance) + + # Alter the image before VM start for, e.g. network injection + if FLAGS.xenapi_inject_image: + VMHelper.preconfigure_instance(self._session, instance, + vdi_ref, network_info) + self.create_vifs(vm_ref, network_info) self.inject_network_info(instance, vm_ref, network_info) return vm_ref diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py index 0c234cb52..99fd35c61 100644 --- a/nova/virt/xenapi_conn.py +++ b/nova/virt/xenapi_conn.py @@ -116,7 +116,7 @@ flags.DEFINE_string('xenapi_agent_path', 'usr/sbin/xe-update-networking', 'Specifies the path in which the xenapi guest agent' ' should be located. If the agent is present,' - ' network configuration if not injected into the image' + ' network configuration is not injected into the image' ' Used only if connection_type=xenapi.' ' and xenapi_inject_image=True') -- cgit From 71bd388a6c04df68e4392dbb7354cc8b14f596fe Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Thu, 24 Mar 2011 15:41:02 -0700 Subject: fix typo --- nova/virt/libvirt.xml.template | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index bcc6b3aed..ff98275fc 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -102,7 +102,7 @@ #if $getVar('vnc_compute_host_iface', False) - + #end if -- cgit From b01742ddb5bfec7e89ccc4cee17800614a0fce3c Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Thu, 24 Mar 2011 15:55:29 -0700 Subject: incorporate feedback from termie --- nova/virt/libvirt.xml.template | 4 ++-- nova/virt/libvirt_conn.py | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index ff98275fc..609784982 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -101,8 +101,8 @@ -#if $getVar('vnc_compute_host_iface', False) - +#if $getVar('vnc_server_host', False) + #end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index c3529f512..cb6384e01 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -516,6 +516,7 @@ class LibvirtConnection(object): def get_vnc_port_for_instance(instance_name): virt_dom = self._conn.lookupByName(instance_name) xml = virt_dom.XMLDesc(0) + # TODO: use etree instead of minidom dom = minidom.parseString(xml) for graphic in dom.getElementsByTagName('graphics'): @@ -735,7 +736,7 @@ class LibvirtConnection(object): 'driver_type': driver_type} if FLAGS.vnc_enabled: - xml_info['vnc_compute_host_iface'] = FLAGS.vnc_compute_host_iface + xml_info['vnc_server_host'] = FLAGS.vnc_server_host if ra_server: xml_info['ra_server'] = ra_server + "/128" if not rescue: -- cgit From f2f08a5b0309876bb312c9124e75bd89331c4816 Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Thu, 24 Mar 2011 17:04:55 -0700 Subject: make everything work with trunk again --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9cd0e8ac9..41adbfe27 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -626,7 +626,7 @@ class LibvirtConnection(driver.ComputeDriver): return {'token': token, 'host': host, 'port': port} - _image_sems = {} # FIXME: why is this here? (anthony) + _image_sems = {} # FIXME: why is this here? (anthony) @staticmethod def _cache_image(fn, target, fname, cow=False, *args, **kwargs): -- cgit From 9632db75d229eac16970af1dfabbb047c2b71a4e Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Fri, 25 Mar 2011 08:20:56 -0400 Subject: Removed partition from setup_container --- nova/virt/disk.py | 4 ++-- nova/virt/libvirt_conn.py | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 0bdb04cde..bbdcc8ddf 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -115,13 +115,13 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): _unlink_device(device, nbd) -def setup_container(image, container_dir=None, partition=None): +def setup_container(image, container_dir=None): """Setup the LXC container It will mount the loopback image to the container directory in order to create the root filesystem for the container """ - nbd = False + nbd = "False" device = _link_device(image, nbd) err = utils.execute('sudo', 'mount', device, container_dir) if err: diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 9fb8ba955..bfb0a75f1 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -798,8 +798,7 @@ class LibvirtConnection(driver.ComputeDriver): if FLAGS.libvirt_type == 'lxc': disk.setup_container(basepath('disk'), - container_dir=container_dir, - partition=target_partition) + container_dir=container_dir) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' -- cgit From 47b54662c17c7af0bca9cf96dc5d4a498706fe8b Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Fri, 25 Mar 2011 08:37:47 -0400 Subject: Dont always assume qemu --- nova/virt/libvirt_conn.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index bfb0a75f1..840eaceeb 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1053,7 +1053,8 @@ class LibvirtConnection(driver.ComputeDriver): total = 0 for dom_id in self._conn.listDomainsID(): dom = self._conn.lookupByID(dom_id) - total += len(dom.vcpus()[1]) + if dom is None: + total += len(dom.vcpus()[1]) return total def get_memory_mb_used(self): -- cgit From 3d8b55294702b531a570b279fb29db8d4ea104d3 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Fri, 25 Mar 2011 08:52:18 -0400 Subject: Fix up templating --- nova/virt/libvirt.xml.template | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index c2c5384bb..26f528cb1 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -83,24 +83,21 @@ #end if #end if #end if - -#for $nic in $nics - - + + - - - -#if $getVar('nic.extra_params', False) - ${nic.extra_params} + + + +#if $getVar('extra_params', False) + ${extra_params} #end if -#if $getVar('nic.gateway_v6', False) - +#if $getVar('gateway_v6', False) + #end if -#end for -- cgit From 6ce4f9c6ae00138184e79cdcfb6f78fc3474580e Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Fri, 25 Mar 2011 08:52:54 -0400 Subject: Fix up destroy container --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index bbdcc8ddf..b9a8fb7e7 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -140,7 +140,7 @@ def destroy_container(target, instance): container_dir = '%s/rootfs' % target utils.execute('sudo', 'umount', container_dir) finally: - out, err = utils('sudo', 'losetup', '-a') + out, err = utils.execute('sudo', 'losetup', '-a') for loop in out.splitlines(): if instance['name'] in loop: device = loop.split(loop, ':') -- cgit From c8fb0c5a16852afc98349edf89bb31afac166749 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Fri, 25 Mar 2011 09:39:20 -0400 Subject: Revert dom check --- nova/virt/libvirt_conn.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 840eaceeb..bfb0a75f1 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -1053,8 +1053,7 @@ class LibvirtConnection(driver.ComputeDriver): total = 0 for dom_id in self._conn.listDomainsID(): dom = self._conn.lookupByID(dom_id) - if dom is None: - total += len(dom.vcpus()[1]) + total += len(dom.vcpus()[1]) return total def get_memory_mb_used(self): -- cgit From c4167bd6174838d1df3c77094a22b19e592e88c1 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Fri, 25 Mar 2011 17:46:28 +0300 Subject: Changed use_ipv6 passing to interfaces.template --- nova/virt/libvirt_conn.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 2cecb010d..d22461301 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -762,11 +762,12 @@ class LibvirtConnection(driver.ComputeDriver): 'dns': network_ref['dns'], 'address_v6': address_v6, 'gateway_v6': network_ref['gateway_v6'], - 'netmask_v6': network_ref['netmask_v6'], - 'use_ipv6': FLAGS.use_ipv6} + 'netmask_v6': network_ref['netmask_v6']} nets.append(net_info) - net = str(Template(ifc_template, searchList=[{'interfaces': nets}])) + net = str(Template(ifc_template, + searchList=[{'interfaces': nets, + 'use_ipv6': FLAGS.use_ipv6}])) if key or net: inst_name = inst['name'] -- cgit From cb8a13e3751cc12f7157094d094c7a26d6f583f0 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Sun, 27 Mar 2011 15:30:47 -0400 Subject: Fix utils checking --- nova/virt/disk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index fd45e2c51..15cd49789 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -124,7 +124,7 @@ def setup_container(image, container_dir=None): """ nbd = "False" device = _link_device(image, nbd) - err = utils.execute('sudo', 'mount', device, container_dir) + out, err = utils.execute('sudo', 'mount', device, container_dir) if err: raise exception.Error(_('Failed to mount filesystem: %s') % err) -- cgit From b3f8e9fb546c621946563af0908e43cb01c50431 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Sun, 27 Mar 2011 18:48:32 -0700 Subject: Bunch of style fixes --- nova/virt/driver.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index 1bc3e4dfc..eafede17a 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -66,8 +66,7 @@ class ComputeDriver(object): raise NotImplementedError() def destroy(self, instance, cleanup=True): - """ - Destroy (shutdown and delete) the specified instance. + """Destroy (shutdown and delete) the specified instance. The given parameter is an instance of nova.compute.service.Instance, and so the instance is being specified as instance.name. @@ -89,12 +88,12 @@ class ComputeDriver(object): raise NotImplementedError() def get_console_pool_info(self, console_type): - """??? + """? Returns a dict containing: - :address: ??? - :username: ??? - :password: ??? + :address: ? + :username: ? + :password: ? """ raise NotImplementedError() @@ -126,7 +125,7 @@ class ComputeDriver(object): raise NotImplementedError() def snapshot(self, instance, image_id): - """ Create snapshot from a running VM instance """ + """Create snapshot from a running VM instance """ raise NotImplementedError() def finish_resize(self, instance, disk_info): -- cgit From 684865d0b95a14f23e9187a6c3a404b5e8ed61ef Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 28 Mar 2011 00:31:28 -0700 Subject: Added poll_rescued_instances to virt driver base class --- nova/virt/driver.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index f9cf1b8aa..fcd31861d 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -232,3 +232,7 @@ class ComputeDriver(object): def inject_network_info(self, instance): """inject network info for specified instance""" raise NotImplementedError() + + def poll_rescued_instances(self, timeout): + """Poll for rescued instances""" + raise NotImplementedError() -- cgit From 8957914ad9dd7691b2a43d977d845e00f7dd48c4 Mon Sep 17 00:00:00 2001 From: Armando Migliaccio Date: Mon, 28 Mar 2011 10:54:29 +0100 Subject: addressed termies review (first round) --- nova/virt/xenapi/network_utils.py | 2 +- nova/virt/xenapi/vmops.py | 149 ++++++++++++++++++++++---------------- 2 files changed, 86 insertions(+), 65 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py index 546f6bea9..94d8e5199 100644 --- a/nova/virt/xenapi/network_utils.py +++ b/nova/virt/xenapi/network_utils.py @@ -44,7 +44,7 @@ class NetworkHelper(HelperBase): """ Return the network on which the bridge is attached, if found. The bridge is defined in the nova db and can be found either in the - 'bridge' or 'name_label' fields of the XenAPI network record + 'bridge' or 'name_label' fields of the XenAPI network record. """ expr = 'field "name__label" = "%s" or ' \ 'field "bridge" = "%s"' % (bridge, bridge) diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 52e1f9eba..9b18ac732 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -58,7 +58,7 @@ class VMOps(object): VMHelper.XenAPI = self.XenAPI def list_instances(self): - """List VM instances""" + """List VM instances.""" # TODO(justinsb): Should we just always use the details method? # Seems to be the same number of API calls.. vm_refs = [] @@ -69,7 +69,7 @@ class VMOps(object): return vm_refs def list_instances_detail(self): - """List VM instances, returning InstanceInfo objects""" + """List VM instances, returning InstanceInfo objects.""" instance_infos = [] for vm_ref in self._session.get_xenapi().VM.get_all(): vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) @@ -119,11 +119,11 @@ class VMOps(object): self._spawn(instance, vm_ref) def spawn_rescue(self, instance): - """Spawn a rescue instance""" + """Spawn a rescue instance.""" self.spawn(instance) def _create_vm(self, instance, vdi_uuid, network_info=None): - """Create VM instance""" + """Create VM instance.""" instance_name = instance.name vm_ref = VMHelper.lookup(self._session, instance_name) if vm_ref is not None: @@ -180,7 +180,7 @@ class VMOps(object): return vm_ref def _spawn(self, instance, vm_ref): - """Spawn a new instance""" + """Spawn a new instance.""" LOG.debug(_('Starting VM %s...'), vm_ref) self._start(instance, vm_ref) instance_name = instance.name @@ -236,7 +236,8 @@ class VMOps(object): return timer.start(interval=0.5, now=True) def _get_vm_opaque_ref(self, instance_or_vm): - """Refactored out the common code of many methods that receive either + """ + Refactored out the common code of many methods that receive either a vm name or a vm instance, and want a vm instance in return. """ # if instance_or_vm is a string it must be opaque ref or instance name @@ -264,21 +265,22 @@ class VMOps(object): return vm_ref def _acquire_bootlock(self, vm): - """Prevent an instance from booting""" + """Prevent an instance from booting.""" self._session.call_xenapi( "VM.set_blocked_operations", vm, {"start": ""}) def _release_bootlock(self, vm): - """Allow an instance to boot""" + """Allow an instance to boot.""" self._session.call_xenapi( "VM.remove_from_blocked_operations", vm, "start") def snapshot(self, instance, image_id): - """Create snapshot from a running VM instance + """ + Create snapshot from a running VM instance :param instance: instance to be snapshotted :param image_id: id of image to upload to @@ -330,11 +332,12 @@ class VMOps(object): return def migrate_disk_and_power_off(self, instance, dest): - """Copies a VHD from one host machine to another + """ + Copies a VHD from one host machine to another - :param instance: the instance that owns the VHD in question - :param dest: the destination host machine - :param disk_type: values are 'primary' or 'cow' + :param instance: the instance that owns the VHD in question. + :param dest: the destination host machine. + :param disk_type: values are 'primary' or 'cow'. """ vm_ref = VMHelper.lookup(self._session, instance.name) @@ -383,7 +386,7 @@ class VMOps(object): return {'base_copy': base_copy_uuid, 'cow': cow_uuid} def link_disks(self, instance, base_copy_uuid, cow_uuid): - """Links the base copy VHD to the COW via the XAPI plugin""" + """Links the base copy VHD to the COW via the XAPI plugin.""" vm_ref = VMHelper.lookup(self._session, instance.name) new_base_copy_uuid = str(uuid.uuid4()) new_cow_uuid = str(uuid.uuid4()) @@ -404,7 +407,7 @@ class VMOps(object): return new_cow_uuid def resize_instance(self, instance, vdi_uuid): - """Resize a running instance by changing it's RAM and disk size """ + """Resize a running instance by changing it's RAM and disk size.""" #TODO(mdietz): this will need to be adjusted for swap later #The new disk size must be in bytes @@ -418,13 +421,14 @@ class VMOps(object): LOG.debug(_("Resize instance %s complete") % (instance.name)) def reboot(self, instance): - """Reboot VM instance""" + """Reboot VM instance.""" vm_ref = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi('Async.VM.clean_reboot', vm_ref) self._session.wait_for_task(task, instance.id) def set_admin_password(self, instance, new_pass): - """Set the root/admin password on the VM instance. This is done via + """ + Set the root/admin password on the VM instance. This is done via an agent running on the VM. Communication between nova and the agent is done via writing xenstore records. Since communication is done over the XenAPI RPC calls, we need to encrypt the password. We're using a @@ -462,7 +466,8 @@ class VMOps(object): return resp_dict['message'] def inject_file(self, instance, path, contents): - """Write a file to the VM instance. The path to which it is to be + """ + Write a file to the VM instance. The path to which it is to be written and the contents of the file need to be supplied; both will be base64-encoded to prevent errors with non-ASCII characters being transmitted. If the agent does not support file injection, or the user @@ -487,7 +492,7 @@ class VMOps(object): return resp_dict['message'] def _shutdown(self, instance, vm_ref, hard=True): - """Shutdown an instance""" + """Shutdown an instance.""" state = self.get_info(instance['name'])['state'] if state == power_state.SHUTDOWN: instance_name = instance.name @@ -511,11 +516,11 @@ class VMOps(object): LOG.exception(exc) def _shutdown_rescue(self, rescue_vm_ref): - """Shutdown a rescue instance""" + """Shutdown a rescue instance.""" self._session.call_xenapi("Async.VM.hard_shutdown", rescue_vm_ref) def _destroy_vdis(self, instance, vm_ref): - """Destroys all VDIs associated with a VM""" + """Destroys all VDIs associated with a VM.""" instance_id = instance.id LOG.debug(_("Destroying VDIs for Instance %(instance_id)s") % locals()) @@ -532,7 +537,7 @@ class VMOps(object): LOG.exception(exc) def _destroy_rescue_vdis(self, rescue_vm_ref): - """Destroys all VDIs associated with a rescued VM""" + """Destroys all VDIs associated with a rescued VM.""" vdi_refs = VMHelper.lookup_vm_vdis(self._session, rescue_vm_ref) for vdi_ref in vdi_refs: try: @@ -541,7 +546,7 @@ class VMOps(object): continue def _destroy_rescue_vbds(self, rescue_vm_ref): - """Destroys all VBDs tied to a rescue VM""" + """Destroys all VBDs tied to a rescue VM.""" vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref) for vbd_ref in vbd_refs: vbd_rec = self._session.get_xenapi().VBD.get_record(vbd_ref) @@ -589,7 +594,7 @@ class VMOps(object): LOG.debug(_("kernel/ramdisk files removed")) def _destroy_vm(self, instance, vm_ref): - """Destroys a VM record""" + """Destroys a VM record.""" instance_id = instance.id try: task = self._session.call_xenapi('Async.VM.destroy', vm_ref) @@ -600,7 +605,7 @@ class VMOps(object): LOG.debug(_("Instance %(instance_id)s VM destroyed") % locals()) def _destroy_rescue_instance(self, rescue_vm_ref): - """Destroy a rescue instance""" + """Destroy a rescue instance.""" self._destroy_rescue_vbds(rescue_vm_ref) self._shutdown_rescue(rescue_vm_ref) self._destroy_rescue_vdis(rescue_vm_ref) @@ -624,10 +629,10 @@ class VMOps(object): """ Destroys VM instance by performing: - 1. A shutdown if requested - 2. Destroying associated VDIs - 3. Destroying kernel and ramdisk files (if necessary) - 4. Destroying that actual VM record + 1. A shutdown if requested. + 2. Destroying associated VDIs. + 3. Destroying kernel and ramdisk files (if necessary). + 4. Destroying that actual VM record. """ if vm_ref is None: LOG.warning(_("VM is not present, skipping destroy...")) @@ -650,36 +655,36 @@ class VMOps(object): callback(ret) def pause(self, instance, callback): - """Pause VM instance""" + """Pause VM instance.""" vm_ref = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi('Async.VM.pause', vm_ref) self._wait_with_callback(instance.id, task, callback) def unpause(self, instance, callback): - """Unpause VM instance""" + """Unpause VM instance.""" vm_ref = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi('Async.VM.unpause', vm_ref) self._wait_with_callback(instance.id, task, callback) def suspend(self, instance, callback): - """suspend the specified instance""" + """Suspend the specified instance""" vm_ref = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi('Async.VM.suspend', vm_ref) self._wait_with_callback(instance.id, task, callback) def resume(self, instance, callback): - """resume the specified instance""" + """Resume the specified instance.""" vm_ref = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi('Async.VM.resume', vm_ref, False, True) self._wait_with_callback(instance.id, task, callback) def rescue(self, instance, callback): - """Rescue the specified instance - - shutdown the instance VM - - set 'bootlock' to prevent the instance from starting in rescue - - spawn a rescue VM (the vm name-label will be instance-N-rescue) - + """ + Rescue the specified instance + - shutdown the instance VM. + - set 'bootlock' to prevent the instance from starting in rescue. + - spawn a rescue VM (the vm name-label will be instance-N-rescue). """ rescue_vm_ref = VMHelper.lookup(self._session, "%s-rescue" % instance.name) @@ -703,9 +708,9 @@ class VMOps(object): def unrescue(self, instance, callback): """Unrescue the specified instance - - unplug the instance VM's disk from the rescue VM - - teardown the rescue VM - - release the bootlock to allow the instance VM to start + - unplug the instance VM's disk from the rescue VM. + - teardown the rescue VM. + - release the bootlock to allow the instance VM to start. """ rescue_vm_ref = VMHelper.lookup(self._session, @@ -723,7 +728,8 @@ class VMOps(object): self._start(instance, original_vm_ref) def poll_rescued_instances(self, timeout): - """Look for expirable rescued instances + """ + Look for expirable rescued instances - forcibly exit rescue mode for any instances that have been in rescue mode for >= the provided timeout """ @@ -761,30 +767,30 @@ class VMOps(object): False) def get_info(self, instance): - """Return data about VM instance""" + """Return data about VM instance.""" vm_ref = self._get_vm_opaque_ref(instance) vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) return VMHelper.compile_info(vm_rec) def get_diagnostics(self, instance): - """Return data about VM diagnostics""" + """Return data about VM diagnostics.""" vm_ref = self._get_vm_opaque_ref(instance) vm_rec = self._session.get_xenapi().VM.get_record(vm_ref) return VMHelper.compile_diagnostics(self._session, vm_rec) def get_console_output(self, instance): - """Return snapshot of console""" + """Return snapshot of console.""" # TODO: implement this to fix pylint! return 'FAKE CONSOLE OUTPUT of instance' def get_ajax_console(self, instance): - """Return link to instance's ajax console""" + """Return link to instance's ajax console.""" # TODO: implement this! return 'http://fakeajaxconsole/fake_url' # TODO(tr3buchet) - remove this function after nova multi-nic def _get_network_info(self, instance): - """creates network info list for instance""" + """Creates network info list for instance.""" admin_context = context.get_admin_context() IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) @@ -826,7 +832,7 @@ class VMOps(object): def inject_network_info(self, instance, vm_ref, network_info): """ Generate the network info and make calls to place it into the - xenstore and the xenstore param list + xenstore and the xenstore param list. """ logging.debug(_("injecting network info to xs for vm: |%s|"), vm_ref) @@ -847,7 +853,7 @@ class VMOps(object): pass def create_vifs(self, vm_ref, network_info): - """Creates vifs for an instance""" + """Creates vifs for an instance.""" logging.debug(_("creating vif(s) for vm: |%s|"), vm_ref) # this function raises if vm_ref is not a vm_opaque_ref @@ -872,7 +878,8 @@ class VMOps(object): args, vm_ref) def list_from_xenstore(self, vm, path): - """Runs the xenstore-ls command to get a listing of all records + """ + Runs the xenstore-ls command to get a listing of all records from 'path' downward. Returns a dict with the sub-paths as keys, and the value stored in those paths as values. If nothing is found at that path, returns None. @@ -881,7 +888,8 @@ class VMOps(object): return json.loads(ret) def read_from_xenstore(self, vm, path): - """Returns the value stored in the xenstore record for the given VM + """ + Returns the value stored in the xenstore record for the given VM at the specified location. A XenAPIPlugin.PluginError will be raised if any error is encountered in the read process. """ @@ -897,7 +905,8 @@ class VMOps(object): return ret def write_to_xenstore(self, vm, path, value): - """Writes the passed value to the xenstore record for the given VM + """ + Writes the passed value to the xenstore record for the given VM at the specified location. A XenAPIPlugin.PluginError will be raised if any error is encountered in the write process. """ @@ -905,7 +914,8 @@ class VMOps(object): {'value': json.dumps(value)}) def clear_xenstore(self, vm, path): - """Deletes the VM's xenstore record for the specified path. + """ + Deletes the VM's xenstore record for the specified path. If there is no such record, the request is ignored. """ self._make_xenstore_call('delete_record', vm, path) @@ -922,7 +932,8 @@ class VMOps(object): def _make_plugin_call(self, plugin, method, vm, path, addl_args=None, vm_ref=None): - """Abstracts out the process of calling a method of a xenapi plugin. + """ + Abstracts out the process of calling a method of a xenapi plugin. Any errors raised by the plugin will in turn raise a RuntimeError here. """ instance_id = vm.id @@ -952,7 +963,8 @@ class VMOps(object): return ret def add_to_xenstore(self, vm, path, key, value): - """Adds the passed key/value pair to the xenstore record for + """ + Adds the passed key/value pair to the xenstore record for the given VM at the specified location. A XenAPIPlugin.PluginError will be raised if any error is encountered in the write process. """ @@ -965,7 +977,8 @@ class VMOps(object): self.write_to_xenstore(vm, path, current) def remove_from_xenstore(self, vm, path, key_or_keys): - """Takes either a single key or a list of keys and removes + """ + Takes either a single key or a list of keys and removes them from the xenstoreirecord data for the given VM. If the key doesn't exist, the request is ignored. """ @@ -992,7 +1005,8 @@ class VMOps(object): ###### names to distinguish them. (dabo) ######################################################################## def read_partial_from_param_xenstore(self, instance_or_vm, key_prefix): - """Returns a dict of all the keys in the xenstore parameter record + """ + Returns a dict of all the keys in the xenstore parameter record for the given instance that begin with the key_prefix. """ data = self.read_from_param_xenstore(instance_or_vm) @@ -1003,7 +1017,8 @@ class VMOps(object): return data def read_from_param_xenstore(self, instance_or_vm, keys=None): - """Returns the xenstore parameter record data for the specified VM + """ + Returns the xenstore parameter record data for the specified VM instance as a dict. Accepts an optional key or list of keys; if a value for 'keys' is passed, the returned dict is filtered to only return the values for those keys. @@ -1025,9 +1040,11 @@ class VMOps(object): return ret def add_to_param_xenstore(self, instance_or_vm, key, val): - """Takes a key/value pair and adds it to the xenstore parameter + """ + Takes a key/value pair and adds it to the xenstore parameter record for the given vm instance. If the key exists in xenstore, - it is overwritten""" + it is overwritten + """ vm_ref = self._get_vm_opaque_ref(instance_or_vm) self.remove_from_param_xenstore(instance_or_vm, key) jsonval = json.dumps(val) @@ -1035,7 +1052,8 @@ class VMOps(object): (vm_ref, key, jsonval)) def write_to_param_xenstore(self, instance_or_vm, mapping): - """Takes a dict and writes each key/value pair to the xenstore + """ + Takes a dict and writes each key/value pair to the xenstore parameter record for the given vm instance. Any existing data for those keys is overwritten. """ @@ -1043,7 +1061,8 @@ class VMOps(object): self.add_to_param_xenstore(instance_or_vm, k, v) def remove_from_param_xenstore(self, instance_or_vm, key_or_keys): - """Takes either a single key or a list of keys and removes + """ + Takes either a single key or a list of keys and removes them from the xenstore parameter record data for the given VM. If the key doesn't exist, the request is ignored. """ @@ -1069,7 +1088,8 @@ def _runproc(cmd): class SimpleDH(object): - """This class wraps all the functionality needed to implement + """ + This class wraps all the functionality needed to implement basic Diffie-Hellman-Merkle key exchange in Python. It features intelligent defaults for the prime and base numbers needed for the calculation, while allowing you to supply your own. It requires that @@ -1078,7 +1098,8 @@ class SimpleDH(object): is not available, a RuntimeError will be raised. """ def __init__(self, prime=None, base=None, secret=None): - """You can specify the values for prime and base if you wish; + """ + You can specify the values for prime and base if you wish; otherwise, reasonable default values will be used. """ if prime is None: -- cgit From df946c08acba6fe1234b13f04d3c46c3973647c2 Mon Sep 17 00:00:00 2001 From: Armando Migliaccio Date: Mon, 28 Mar 2011 11:52:28 +0100 Subject: addressed termie's review (second round) --- nova/virt/xenapi/fake.py | 156 ++++++++++++++++++++++------------------------ nova/virt/xenapi/vmops.py | 2 +- 2 files changed, 74 insertions(+), 84 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index 6d17a642e..d084c725f 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -78,7 +78,10 @@ def reset(): for c in _CLASSES: _db_content[c] = {} create_host('fake') - create_vm('fake', 'Running', is_a_template=False, is_control_domain=True) + create_vm('fake', + 'Running', + is_a_template=False, + is_control_domain=True) def reset_table(table): @@ -88,26 +91,23 @@ def reset_table(table): def create_host(name_label): - return _create_object('host', { - 'name_label': name_label, - }) + return _create_object('host', + {'name_label': name_label}) def create_network(name_label, bridge): - return _create_object('network', { - 'name_label': name_label, - 'bridge': bridge, - }) + return _create_object('network', + {'name_label': name_label, + 'bridge': bridge}) def create_vm(name_label, status, is_a_template=False, is_control_domain=False): - return _create_object('VM', { - 'name_label': name_label, - 'power-state': status, - 'is_a_template': is_a_template, - 'is_control_domain': is_control_domain, - }) + return _create_object('VM', + {'name_label': name_label, + 'power-state': status, + 'is_a_template': is_a_template, + 'is_control_domain': is_control_domain}) def destroy_vm(vm_ref): @@ -129,27 +129,24 @@ def destroy_vdi(vdi_ref): def create_vdi(name_label, read_only, sr_ref, sharable): - return _create_object('VDI', { - 'name_label': name_label, - 'read_only': read_only, - 'SR': sr_ref, - 'type': '', - 'name_description': '', - 'sharable': sharable, - 'other_config': {}, - 'location': '', - 'xenstore_data': '', - 'sm_config': {}, - 'VBDs': {}, - }) + return _create_object('VDI', + {'name_label': name_label, + 'read_only': read_only, + 'SR': sr_ref, + 'type': '', + 'name_description': '', + 'sharable': sharable, + 'other_config': {}, + 'location': '', + 'xenstore_data': '', + 'sm_config': {}, + 'VBDs': {}}) def create_vbd(vm_ref, vdi_ref): - vbd_rec = { - 'VM': vm_ref, - 'VDI': vdi_ref, - 'currently_attached': False, - } + vbd_rec = {'VM': vm_ref, + 'VDI': vdi_ref, + 'currently_attached': False} vbd_ref = _create_object('VBD', vbd_rec) after_VBD_create(vbd_ref, vbd_rec) return vbd_ref @@ -175,19 +172,17 @@ def after_VM_create(vm_ref, vm_rec): def create_pbd(config, host_ref, sr_ref, attached): - return _create_object('PBD', { - 'device-config': config, - 'host': host_ref, - 'SR': sr_ref, - 'currently-attached': attached, - }) + return _create_object('PBD', + {'device-config': config, + 'host': host_ref, + 'SR': sr_ref, + 'currently-attached': attached}) def create_task(name_label): - return _create_object('task', { - 'name_label': name_label, - 'status': 'pending', - }) + return _create_object('task', + {'name_label': name_label, + 'status': 'pending'}) def create_local_pifs(): @@ -205,34 +200,32 @@ def create_local_srs(): def _create_local_sr(host_ref): - sr_ref = _create_object('SR', { - 'name_label': 'Local storage', - 'type': 'lvm', - 'content_type': 'user', - 'shared': False, - 'physical_size': str(1 << 30), - 'physical_utilisation': str(0), - 'virtual_allocation': str(0), - 'other_config': { - 'i18n-original-value-name_label': 'Local storage', - 'i18n-key': 'local-storage', - }, - 'VDIs': [] - }) + sr_ref = \ + _create_object('SR', + {'name_label': 'Local storage', + 'type': 'lvm', + 'content_type': 'user', + 'shared': False, + 'physical_size': str(1 << 30), + 'physical_utilisation': str(0), + 'virtual_allocation': str(0), + 'other_config': {'i18n-original-value-name_label': \ + 'Local storage', + 'i18n-key': 'local-storage'}, + 'VDIs': []}) pbd_ref = create_pbd('', host_ref, sr_ref, True) _db_content['SR'][sr_ref]['PBDs'] = [pbd_ref] return sr_ref def _create_local_pif(host_ref): - pif_ref = _create_object('PIF', { - 'name-label': 'Fake PIF', - 'MAC': '00:11:22:33:44:55', - 'physical': True, - 'VLAN': -1, - 'device': 'fake0', - 'host_uuid': host_ref, - }) + pif_ref = _create_object('PIF', + {'name-label': 'Fake PIF', + 'MAC': '00:11:22:33:44:55', + 'physical': True, + 'VLAN': -1, + 'device': 'fake0', + 'host_uuid': host_ref}) def _create_object(table, obj): @@ -260,19 +253,17 @@ def _create_sr(table, obj): def _create_vlan(pif_ref, vlan_num, network_ref): pif_rec = get_record('PIF', pif_ref) - vlan_pif_ref = _create_object('PIF', { - 'name-label': 'Fake VLAN PIF', - 'MAC': '00:11:22:33:44:55', - 'physical': True, - 'VLAN': vlan_num, - 'device': pif_rec['device'], - 'host_uuid': pif_rec['host_uuid'], - }) - return _create_object('VLAN', { - 'tagged-pif': pif_ref, - 'untagged-pif': vlan_pif_ref, - 'tag': vlan_num, - }) + vlan_pif_ref = _create_object('PIF', + {'name-label': 'Fake VLAN PIF', + 'MAC': '00:11:22:33:44:55', + 'physical': True, + 'VLAN': vlan_num, + 'device': pif_rec['device'], + 'host_uuid': pif_rec['host_uuid']}) + return _create_object('VLAN', + {'tagged-pif': pif_ref, + 'untagged-pif': vlan_pif_ref, + 'tag': vlan_num}) def get_all(table): @@ -334,7 +325,7 @@ class SessionBase(object): rec['device'] = '' def PIF_get_all_records_where(self, _1, _2): - # TODO (salvatore-orlando):filter table on _2 + # TODO (salvatore-orlando): filter table on _2 return _db_content['PIF'] def VM_get_xenstore_data(self, _1, vm_ref): @@ -347,7 +338,7 @@ class SessionBase(object): db_ref['xenstore_data'][key] = None def network_get_all_records_where(self, _1, _2): - # TODO (salvatore-orlando):filter table on _2 + # TODO (salvatore-orlando): filter table on _2 return _db_content['network'] def VM_add_to_xenstore_data(self, _1, vm_ref, key, value): @@ -385,10 +376,9 @@ class SessionBase(object): def _login(self, method, params): self._session = str(uuid.uuid4()) - _db_content['session'][self._session] = { - 'uuid': str(uuid.uuid4()), - 'this_host': _db_content['host'].keys()[0], - } + _db_content['session'][self._session] = \ + {'uuid': str(uuid.uuid4()), + 'this_host': _db_content['host'].keys()[0]} def _logout(self): s = self._session diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 9b18ac732..08046318e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -338,6 +338,7 @@ class VMOps(object): :param instance: the instance that owns the VHD in question. :param dest: the destination host machine. :param disk_type: values are 'primary' or 'cow'. + """ vm_ref = VMHelper.lookup(self._session, instance.name) @@ -711,7 +712,6 @@ class VMOps(object): - unplug the instance VM's disk from the rescue VM. - teardown the rescue VM. - release the bootlock to allow the instance VM to start. - """ rescue_vm_ref = VMHelper.lookup(self._session, "%s-rescue" % instance.name) -- cgit From 184fa8239d54d20ff294cdb019d07989ed3d6c4d Mon Sep 17 00:00:00 2001 From: Armando Migliaccio Date: Mon, 28 Mar 2011 12:08:43 +0100 Subject: addressed termies review (third round) --- nova/virt/xenapi/fake.py | 2 +- nova/virt/xenapi/vmops.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index d084c725f..d79312a60 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -60,7 +60,7 @@ from nova import exception from nova import log as logging -_CLASSES = ['host', 'network', 'session', 'SR', 'VBD',\ +_CLASSES = ['host', 'network', 'session', 'SR', 'VBD', \ 'PBD', 'VDI', 'VIF', 'PIF', 'VM', 'VLAN', 'task'] _db_content = {} diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 08046318e..147419f90 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -668,7 +668,7 @@ class VMOps(object): self._wait_with_callback(instance.id, task, callback) def suspend(self, instance, callback): - """Suspend the specified instance""" + """Suspend the specified instance.""" vm_ref = self._get_vm_opaque_ref(instance) task = self._session.call_xenapi('Async.VM.suspend', vm_ref) self._wait_with_callback(instance.id, task, callback) @@ -686,6 +686,7 @@ class VMOps(object): - shutdown the instance VM. - set 'bootlock' to prevent the instance from starting in rescue. - spawn a rescue VM (the vm name-label will be instance-N-rescue). + """ rescue_vm_ref = VMHelper.lookup(self._session, "%s-rescue" % instance.name) -- cgit From 8922630e70e97b52e363a861c76fe4a01b8418ff Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Mon, 28 Mar 2011 09:37:05 -0400 Subject: Fix typo in libvirt xml template --- nova/virt/libvirt.xml.template | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 26f528cb1..a62c3b6a8 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -3,7 +3,7 @@ ${memory_kb} #if $type == 'lxc' - #set $disk prefix = '' + #set $disk_prefix = '' #set $disk_bus = '' exe /sbin/init -- cgit From 805cb3609379827d1643785be83f75b69b602d74 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Mon, 28 Mar 2011 13:44:33 -0400 Subject: Fix libvirt merge mistake --- nova/virt/libvirt.xml.template | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index a62c3b6a8..894b216e9 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -83,22 +83,24 @@ #end if #end if #end if + +#for $nic in $nics - - + + - - - -#if $getVar('extra_params', False) - ${extra_params} + + + +#if $getVar('nic.extra_params', False) + ${nic.extra_params} #end if -#if $getVar('gateway_v6', False) - +#if $getVar('nic.gateway_v6', False) + #end if - +#end for -- cgit From dbf14e9b6cc337233ef95b03fd1c2fdba8ebf8a7 Mon Sep 17 00:00:00 2001 From: termie Date: Mon, 28 Mar 2011 10:47:08 -0700 Subject: add snapshot support for libvirt --- nova/virt/libvirt_conn.py | 71 +++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 65 insertions(+), 6 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 36457ee87..4456ffc12 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -38,12 +38,15 @@ Supports KVM, QEMU, UML, and XEN. import multiprocessing import os -import shutil -import sys import random +import shutil import subprocess +import sys +import tempfile +import time import uuid from xml.dom import minidom +from xml.etree import ElementTree from eventlet import greenthread from eventlet import tpool @@ -111,6 +114,8 @@ flags.DEFINE_string('live_migration_flag', 'Define live migration behavior.') flags.DEFINE_integer('live_migration_bandwidth', 0, 'Define live migration behavior') +flags.DEFINE_string('qemu_img', 'qemu-img', + 'binary to use for qemu-img commands') def get_connection(read_only): @@ -397,10 +402,64 @@ class LibvirtConnection(driver.ComputeDriver): @exception.wrap_exception def snapshot(self, instance, image_id): - """ Create snapshot from a running VM instance """ - raise NotImplementedError( - _("Instance snapshotting is not supported for libvirt" - "at this time")) + """Create snapshot from a running VM instance. + + This command only works with qemu 0.14+, the qemu_img flag is + provided so that a locally compiled binary of qemu-img can be used + to support this command. + + """ + image_service = utils.import_object(FLAGS.image_service) + virt_dom = self._conn.lookupByName(instance['name']) + elevated = context.get_admin_context() + + base = image_service.show(elevated, instance['image_id']) + + metadata = {'type': 'machine', + 'is_public': False, + 'properties': {'architecture': base['architecture'], + 'kernel_id': instance['kernel_id'], + 'image_location': 'snapshot', + 'image_state': 'available', + 'owner_id': instance['project_id'], + 'ramdisk_id': instance['ramdisk_id'], + } + } + + # Make the snapshot + snapshot_name = uuid.uuid4().hex + snapshot_xml = """ + + %s + + """ % snapshot_name + snapshot_ptr = virt_dom.snapshotCreateXML(snapshot_xml, 0) + + # Find the disk + xml_desc = virt_dom.XMLDesc(0) + domain = ElementTree.fromstring(xml_desc) + source = domain.find('devices/disk/source') + disk_path = source.get('file') + + # Export the snapshot to a raw image + temp_dir = tempfile.mkdtemp() + out_path = os.path.join(temp_dir, snapshot_name) + qemu_img_cmd = '%s convert -f qcow2 -O raw -s %s %s %s' % ( + FLAGS.qemu_img, + snapshot_name, + disk_path, + out_path) + utils.execute(qemu_img_cmd) + + # Upload that image to the image service + with open(out_path) as image_file: + image_service.update(elevated, + image_id, + metadata, + image_file) + + # Clean up + shutil.rmtree(temp_dir) @exception.wrap_exception def reboot(self, instance): -- cgit From 1e4024b72218a07d1e535878337547cf16406dd8 Mon Sep 17 00:00:00 2001 From: termie Date: Mon, 28 Mar 2011 10:47:11 -0700 Subject: update glance params per review --- nova/virt/libvirt_conn.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 4456ffc12..80eb64f3c 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -415,9 +415,12 @@ class LibvirtConnection(driver.ComputeDriver): base = image_service.show(elevated, instance['image_id']) - metadata = {'type': 'machine', + metadata = {'disk_format': base['disk_format'], + 'container_format': base['container_format'], 'is_public': False, 'properties': {'architecture': base['architecture'], + 'type': base['type'], + 'name': '%s.%s' % (base['name'], image_id), 'kernel_id': instance['kernel_id'], 'image_location': 'snapshot', 'image_state': 'available', -- cgit From dbbceaebec3ca2a729582f9851f718b2b7c3f3b9 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Mon, 28 Mar 2011 15:57:18 -0400 Subject: Fix up libvirt.xml.template --- nova/virt/libvirt.xml.template | 138 ++++++++++++++++++++--------------------- 1 file changed, 68 insertions(+), 70 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index 894b216e9..36d18ed95 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -3,47 +3,45 @@ ${memory_kb} #if $type == 'lxc' - #set $disk_prefix = '' - #set $disk_bus = '' - exe - /sbin/init + #set $disk_prefix = '' + #set $disk_bus = '' + exe + /sbin/init +#else if $type == 'uml' + #set $disk_prefix = 'ubd' + #set $disk_bus = 'uml' + uml + /usr/bin/linux + /dev/ubda #else - #if $type == 'uml' - #set $disk_prefix = 'ubd' - #set $disk_bus = 'uml' - uml - /usr/bin/linux - /dev/ubda - #else - #if $type == 'xen' - #set $disk_prefix = 'sd' - #set $disk_bus = 'scsi' - linux - /dev/xvda - #else - #set $disk_prefix = 'vd' - #set $disk_bus = 'virtio' - hvm - #end if - #if $getVar('rescue', False) - ${basepath}/kernel.rescue - ${basepath}/ramdisk.rescue - #else - #if $getVar('kernel', None) - ${kernel} - #if $type == 'xen' - ro - #else - root=/dev/vda console=ttyS0 - #end if - #if $getVar('ramdisk', None) - ${ramdisk} - #end if - #else - - #end if - #end if - #end if + #if $type == 'xen' + #set $disk_prefix = 'sd' + #set $disk_bus = 'scsi' + linux + /dev/xvda + #else + #set $disk_prefix = 'vd' + #set $disk_bus = 'virtio' + hvm + #end if + #if $getVar('rescue', False) + ${basepath}/kernel.rescue + ${basepath}/ramdisk.rescue + #else + #if $getVar('kernel', None) + ${kernel} + #if $type == 'xen' + ro + #else + root=/dev/vda console=ttyS0 + #end if + #if $getVar('ramdisk', None) + ${ramdisk} + #end if + #else + + #end if + #end if #end if @@ -52,36 +50,36 @@ ${vcpus} #if $type == 'lxc' - - - - + + + + #else - #if $getVar('rescue', False) - - - - - - - - - - - #else - - - - - - #if $getVar('local', False) - - - - - - #end if -#end if + #if $getVar('rescue', False) + + + + + + + + + + + #else + + + + + + #if $getVar('local', False) + + + + + + #end if + #end if #end if #for $nic in $nics @@ -91,7 +89,7 @@ - + #if $getVar('nic.extra_params', False) ${nic.extra_params} #end if -- cgit From c1ed5fc3dfeecef281df45cd2e6779fa21c63bf5 Mon Sep 17 00:00:00 2001 From: Armando Migliaccio Date: Mon, 28 Mar 2011 22:00:17 +0100 Subject: style fixes --- nova/virt/xenapi/fake.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py index d79312a60..4434dbf0b 100644 --- a/nova/virt/xenapi/fake.py +++ b/nova/virt/xenapi/fake.py @@ -60,7 +60,7 @@ from nova import exception from nova import log as logging -_CLASSES = ['host', 'network', 'session', 'SR', 'VBD', \ +_CLASSES = ['host', 'network', 'session', 'SR', 'VBD', 'PBD', 'VDI', 'VIF', 'PIF', 'VM', 'VLAN', 'task'] _db_content = {} @@ -200,19 +200,19 @@ def create_local_srs(): def _create_local_sr(host_ref): - sr_ref = \ - _create_object('SR', - {'name_label': 'Local storage', - 'type': 'lvm', - 'content_type': 'user', - 'shared': False, - 'physical_size': str(1 << 30), - 'physical_utilisation': str(0), - 'virtual_allocation': str(0), - 'other_config': {'i18n-original-value-name_label': \ - 'Local storage', - 'i18n-key': 'local-storage'}, - 'VDIs': []}) + sr_ref = _create_object( + 'SR', + {'name_label': 'Local storage', + 'type': 'lvm', + 'content_type': 'user', + 'shared': False, + 'physical_size': str(1 << 30), + 'physical_utilisation': str(0), + 'virtual_allocation': str(0), + 'other_config': { + 'i18n-original-value-name_label': 'Local storage', + 'i18n-key': 'local-storage'}, + 'VDIs': []}) pbd_ref = create_pbd('', host_ref, sr_ref, True) _db_content['SR'][sr_ref]['PBDs'] = [pbd_ref] return sr_ref -- cgit From cd81e06c19893b44568a8cef37a1de30b726e236 Mon Sep 17 00:00:00 2001 From: Armando Migliaccio Date: Mon, 28 Mar 2011 22:25:11 +0100 Subject: fix docstrings --- nova/virt/xenapi/vmops.py | 61 +++++++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 28 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index 147419f90..a9514bd61 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -279,8 +279,7 @@ class VMOps(object): "start") def snapshot(self, instance, image_id): - """ - Create snapshot from a running VM instance + """Create snapshot from a running VM instance. :param instance: instance to be snapshotted :param image_id: id of image to upload to @@ -300,6 +299,7 @@ class VMOps(object): 3. Push-to-glance: Once coalesced, we call a plugin on the XenServer that will bundle the VHDs together and then push the bundle into Glance. + """ template_vm_ref = None try: @@ -332,8 +332,7 @@ class VMOps(object): return def migrate_disk_and_power_off(self, instance, dest): - """ - Copies a VHD from one host machine to another + """Copies a VHD from one host machine to another. :param instance: the instance that owns the VHD in question. :param dest: the destination host machine. @@ -428,13 +427,14 @@ class VMOps(object): self._session.wait_for_task(task, instance.id) def set_admin_password(self, instance, new_pass): - """ - Set the root/admin password on the VM instance. This is done via - an agent running on the VM. Communication between nova and the agent - is done via writing xenstore records. Since communication is done over - the XenAPI RPC calls, we need to encrypt the password. We're using a - simple Diffie-Hellman class instead of the more advanced one in - M2Crypto for compatibility with the agent code. + """Set the root/admin password on the VM instance. + + This is done via an agent running on the VM. Communication between nova + and the agent is done via writing xenstore records. Since communication + is done over the XenAPI RPC calls, we need to encrypt the password. + We're using a simple Diffie-Hellman class instead of the more advanced + one in M2Crypto for compatibility with the agent code. + """ # Need to uniquely identify this request. transaction_id = str(uuid.uuid4()) @@ -467,12 +467,14 @@ class VMOps(object): return resp_dict['message'] def inject_file(self, instance, path, contents): - """ - Write a file to the VM instance. The path to which it is to be - written and the contents of the file need to be supplied; both will - be base64-encoded to prevent errors with non-ASCII characters being - transmitted. If the agent does not support file injection, or the user - has disabled it, a NotImplementedError will be raised. + """Write a file to the VM instance. + + The path to which it is to be written and the contents of the file + need to be supplied; both will be base64-encoded to prevent errors + with non-ASCII characters being transmitted. If the agent does not + support file injection, or the user has disabled it, a + NotImplementedError will be raised. + """ # Files/paths must be base64-encoded for transmission to agent b64_path = base64.b64encode(path) @@ -556,8 +558,7 @@ class VMOps(object): VMHelper.destroy_vbd(self._session, vbd_ref) def _destroy_kernel_ramdisk(self, instance, vm_ref): - """ - Three situations can occur: + """Three situations can occur: 1. We have neither a ramdisk nor a kernel, in which case we are a RAW image and can omit this step @@ -567,6 +568,7 @@ class VMOps(object): 3. We have both, in which case we safely remove both the kernel and the ramdisk. + """ instance_id = instance.id if not instance.kernel_id and not instance.ramdisk_id: @@ -614,11 +616,11 @@ class VMOps(object): self._session.call_xenapi("Async.VM.destroy", rescue_vm_ref) def destroy(self, instance): - """ - Destroy VM instance + """Destroy VM instance. This is the method exposed by xenapi_conn.destroy(). The rest of the destroy_* methods are internal. + """ instance_id = instance.id LOG.info(_("Destroying VM for Instance %(instance_id)s") % locals()) @@ -627,13 +629,13 @@ class VMOps(object): def _destroy(self, instance, vm_ref, shutdown=True, destroy_kernel_ramdisk=True): - """ - Destroys VM instance by performing: + """Destroys VM instance by performing: 1. A shutdown if requested. 2. Destroying associated VDIs. 3. Destroying kernel and ramdisk files (if necessary). 4. Destroying that actual VM record. + """ if vm_ref is None: LOG.warning(_("VM is not present, skipping destroy...")) @@ -681,8 +683,8 @@ class VMOps(object): self._wait_with_callback(instance.id, task, callback) def rescue(self, instance, callback): - """ - Rescue the specified instance + """Rescue the specified instance. + - shutdown the instance VM. - set 'bootlock' to prevent the instance from starting in rescue. - spawn a rescue VM (the vm name-label will be instance-N-rescue). @@ -709,10 +711,12 @@ class VMOps(object): self._session.call_xenapi("Async.VBD.plug", rescue_vbd_ref) def unrescue(self, instance, callback): - """Unrescue the specified instance + """Unrescue the specified instance. + - unplug the instance VM's disk from the rescue VM. - teardown the rescue VM. - release the bootlock to allow the instance VM to start. + """ rescue_vm_ref = VMHelper.lookup(self._session, "%s-rescue" % instance.name) @@ -729,10 +733,11 @@ class VMOps(object): self._start(instance, original_vm_ref) def poll_rescued_instances(self, timeout): - """ - Look for expirable rescued instances + """Look for expirable rescued instances. + - forcibly exit rescue mode for any instances that have been in rescue mode for >= the provided timeout + """ last_ran = self.poll_rescue_last_ran if not last_ran: -- cgit From 276c153f44734e78cae25deb9fc9e79a604c6219 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 28 Mar 2011 16:42:28 -0700 Subject: More fixes to keep the stylebot happy --- nova/virt/driver.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index eafede17a..f85796a97 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -125,7 +125,7 @@ class ComputeDriver(object): raise NotImplementedError() def snapshot(self, instance, image_id): - """Create snapshot from a running VM instance """ + """Create snapshot from a running VM instance.""" raise NotImplementedError() def finish_resize(self, instance, disk_info): -- cgit From 699f82e7e14146feb272d61a98b89ad53c93bf08 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Mon, 28 Mar 2011 17:11:16 -0700 Subject: Yet more docstring fixes --- nova/virt/driver.py | 2 ++ 1 file changed, 2 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index 55281b741..c6c28b2ba 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -77,6 +77,7 @@ class ComputeDriver(object): If the instance is not found (for example if networking failed), this function should still succeed. It's probably a good idea to log a warning in that case. + """ raise NotImplementedError() @@ -94,6 +95,7 @@ class ComputeDriver(object): :address: ? :username: ? :password: ? + """ raise NotImplementedError() -- cgit From 0e81c4175cad97359e848c993efd9a91eb981174 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Mon, 28 Mar 2011 21:22:53 -0400 Subject: Pass along the nbd flags although we dont support it just yet --- nova/virt/disk.py | 13 ++++++++----- nova/virt/libvirt_conn.py | 5 +++-- 2 files changed, 11 insertions(+), 7 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 15cd49789..11a7a969e 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -116,13 +116,14 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): _unlink_device(device, nbd) -def setup_container(image, container_dir=None): +def setup_container(image, container_dir=None, nbd=False): """Setup the LXC container It will mount the loopback image to the container directory in order - to create the root filesystem for the container + to create the root filesystem for the container. + + LXC does not support qcow2 images yet. """ - nbd = "False" device = _link_device(image, nbd) out, err = utils.execute('sudo', 'mount', device, container_dir) if err: @@ -131,11 +132,13 @@ def setup_container(image, container_dir=None): _unlink_device(device, nbd) -def destroy_container(target, instance): +def destroy_container(target, instance, nbd=False): """Destroy the container once it terminates It will umount the container that is mounted, try to find the loopback device associated with the container and delete it. + + LXC does not support qcow2 images yet. """ try: container_dir = '%s/rootfs' % target @@ -145,7 +148,7 @@ def destroy_container(target, instance): for loop in out.splitlines(): if instance['name'] in loop: device = loop.split(loop, ':') - utils.execute('sudo', 'losetup', '--detach', device) + _unlink_device(device, nbd) def _link_device(image, nbd): diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 66d0d195b..af2dac9e8 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -342,7 +342,7 @@ class LibvirtConnection(driver.ComputeDriver): LOG.info(_('instance %(instance_name)s: deleting instance files' ' %(target)s') % locals()) if FLAGS.libvirt_type == 'lxc': - disk.destroy_container(target, instance) + disk.destroy_container(target, instance,nbd=FLAGS.use_cow_images) if os.path.exists(target): shutil.rmtree(target) @@ -797,7 +797,8 @@ class LibvirtConnection(driver.ComputeDriver): if FLAGS.libvirt_type == 'lxc': disk.setup_container(basepath('disk'), - container_dir=container_dir) + container_dir=container_dir, + nbd=FLAGS.use_cow_images) except Exception as e: # This could be a windows image, or a vmdk format disk LOG.warn(_('instance %(inst_name)s: ignoring error injecting' -- cgit From 73f05da6400fe7f4324cf98c7d0706fb68a62870 Mon Sep 17 00:00:00 2001 From: Armando Migliaccio Date: Tue, 29 Mar 2011 11:20:16 +0100 Subject: sorted pep8 errors that were introduced during previous fixes --- nova/virt/xenapi/vmops.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py index a9514bd61..c96c35a6e 100644 --- a/nova/virt/xenapi/vmops.py +++ b/nova/virt/xenapi/vmops.py @@ -430,7 +430,7 @@ class VMOps(object): """Set the root/admin password on the VM instance. This is done via an agent running on the VM. Communication between nova - and the agent is done via writing xenstore records. Since communication + and the agent is done via writing xenstore records. Since communication is done over the XenAPI RPC calls, we need to encrypt the password. We're using a simple Diffie-Hellman class instead of the more advanced one in M2Crypto for compatibility with the agent code. @@ -467,12 +467,12 @@ class VMOps(object): return resp_dict['message'] def inject_file(self, instance, path, contents): - """Write a file to the VM instance. + """Write a file to the VM instance. The path to which it is to be written and the contents of the file need to be supplied; both will be base64-encoded to prevent errors with non-ASCII characters being transmitted. If the agent does not - support file injection, or the user has disabled it, a + support file injection, or the user has disabled it, a NotImplementedError will be raised. """ -- cgit From ad6735df0de8676768353516eee4af62af2c993c Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Tue, 29 Mar 2011 08:56:42 -0400 Subject: Catch the error that mount might through a bit better --- nova/virt/disk.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 11a7a969e..8adef744f 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -124,11 +124,11 @@ def setup_container(image, container_dir=None, nbd=False): LXC does not support qcow2 images yet. """ - device = _link_device(image, nbd) - out, err = utils.execute('sudo', 'mount', device, container_dir) - if err: - raise exception.Error(_('Failed to mount filesystem: %s') - % err) + try: + device = _link_device(image, nbd) + utils.execute('sudo', 'mount', device, container_dir) + except Exception, exn: + LOG.exception(_('Failed to mount filesystem: %s'), exn) _unlink_device(device, nbd) -- cgit From beec33e8dbffbe3ea02eccec4952705698db377a Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Tue, 29 Mar 2011 10:01:54 -0400 Subject: Fix pep8 error --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index c4d41881d..ae3a967a4 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -347,7 +347,7 @@ class LibvirtConnection(driver.ComputeDriver): LOG.info(_('instance %(instance_name)s: deleting instance files' ' %(target)s') % locals()) if FLAGS.libvirt_type == 'lxc': - disk.destroy_container(target, instance,nbd=FLAGS.use_cow_images) + disk.destroy_container(target, instance, nbd=FLAGS.use_cow_images) if os.path.exists(target): shutil.rmtree(target) -- cgit From 3b8aa1fed7cd6d1deb580eec0af283947060c04d Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Tue, 29 Mar 2011 21:26:17 +0400 Subject: Added checks that exists at least one network marked inhected in libvirt and xenapi --- nova/virt/libvirt_conn.py | 5 ++++- nova/virt/xenapi/vm_utils.py | 6 +++++- 2 files changed, 9 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 80eb64f3c..7dd09813d 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -803,6 +803,7 @@ class LibvirtConnection(driver.ComputeDriver): nets = [] ifc_template = open(FLAGS.injected_network_template).read() ifc_num = -1 + have_injected_networks = False admin_context = context.get_admin_context() for (network_ref, mapping) in network_info: ifc_num += 1 @@ -810,6 +811,7 @@ class LibvirtConnection(driver.ComputeDriver): if not 'injected' in network_ref: continue + have_injected_networks = True address = mapping['ips'][0]['ip'] address_v6 = None if FLAGS.use_ipv6: @@ -825,7 +827,8 @@ class LibvirtConnection(driver.ComputeDriver): 'netmask_v6': network_ref['netmask_v6']} nets.append(net_info) - net = str(Template(ifc_template, + if have_injected_networks: + net = str(Template(ifc_template, searchList=[{'interfaces': nets, 'use_ipv6': FLAGS.use_ipv6}])) diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 2288ea8a5..18c29134d 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -1108,11 +1108,13 @@ def _prepare_injectables(inst, networks_info): if networks_info: ifc_num = -1 interfaces_info = [] + have_injected_networks = False for (network_ref, info) in networks_info: ifc_num += 1 if not network_ref['injected']: continue + have_injected_networks = True ip_v4 = ip_v6 = None if 'ips' in info and len(info['ips']) > 0: ip_v4 = info['ips'][0] @@ -1131,7 +1133,9 @@ def _prepare_injectables(inst, networks_info): 'gateway_v6': ip_v6 and ip_v6['gateway'] or '', 'use_ipv6': FLAGS.use_ipv6} interfaces_info.append(interface_info) - net = str(template(template_data, + + if have_injected_networks: + net = str(template(template_data, searchList=[{'interfaces': interfaces_info, 'use_ipv6': FLAGS.use_ipv6}])) return key, net -- cgit From 8f4176f289142e48d4a2c584ad1ce270dfa53d82 Mon Sep 17 00:00:00 2001 From: Chuck Short Date: Tue, 29 Mar 2011 14:56:46 -0400 Subject: Fix up docstring --- nova/virt/disk.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/disk.py b/nova/virt/disk.py index 8adef744f..ddea1a1f7 100644 --- a/nova/virt/disk.py +++ b/nova/virt/disk.py @@ -117,7 +117,7 @@ def inject_data(image, key=None, net=None, partition=None, nbd=False): def setup_container(image, container_dir=None, nbd=False): - """Setup the LXC container + """Setup the LXC container. It will mount the loopback image to the container directory in order to create the root filesystem for the container. @@ -133,7 +133,7 @@ def setup_container(image, container_dir=None, nbd=False): def destroy_container(target, instance, nbd=False): - """Destroy the container once it terminates + """Destroy the container once it terminates. It will umount the container that is mounted, try to find the loopback device associated with the container and delete it. -- cgit From b161ae983edbd9e8c302907e8951075546eafc48 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Tue, 29 Mar 2011 23:30:06 +0400 Subject: style fix --- nova/virt/libvirt_conn.py | 4 ++-- nova/virt/xenapi/vm_utils.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 7dd09813d..aaa0fe8d3 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -829,8 +829,8 @@ class LibvirtConnection(driver.ComputeDriver): if have_injected_networks: net = str(Template(ifc_template, - searchList=[{'interfaces': nets, - 'use_ipv6': FLAGS.use_ipv6}])) + searchList=[{'interfaces': nets, + 'use_ipv6': FLAGS.use_ipv6}])) if key or net: inst_name = inst['name'] diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py index 18c29134d..d07d60800 100644 --- a/nova/virt/xenapi/vm_utils.py +++ b/nova/virt/xenapi/vm_utils.py @@ -1136,6 +1136,6 @@ def _prepare_injectables(inst, networks_info): if have_injected_networks: net = str(template(template_data, - searchList=[{'interfaces': interfaces_info, - 'use_ipv6': FLAGS.use_ipv6}])) + searchList=[{'interfaces': interfaces_info, + 'use_ipv6': FLAGS.use_ipv6}])) return key, net -- cgit From dbef49203985b4eea82912d010df7204ec68586c Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Tue, 29 Mar 2011 13:32:03 -0700 Subject: fix flag names --- nova/virt/libvirt.xml.template | 4 ++-- nova/virt/libvirt_conn.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template index c492e488c..cf6bed530 100644 --- a/nova/virt/libvirt.xml.template +++ b/nova/virt/libvirt.xml.template @@ -104,8 +104,8 @@ -#if $getVar('vnc_server_host', False) - +#if $getVar('vncserver_host', False) + #end if diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 41adbfe27..ec09aca28 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -885,7 +885,7 @@ class LibvirtConnection(driver.ComputeDriver): 'nics': nics} if FLAGS.vnc_enabled: - xml_info['vnc_server_host'] = FLAGS.vnc_server_host + xml_info['vncserver_host'] = FLAGS.vncserver_host if not rescue: if instance['kernel_id']: xml_info['kernel'] = xml_info['basepath'] + "/kernel" -- cgit From cc7ba9a7a4ed8a38f217ad7f33fc33254f80ead7 Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Tue, 29 Mar 2011 13:47:47 -0700 Subject: move flags per termie's feedback --- nova/virt/libvirt_conn.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index ec09aca28..8c948950b 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -57,6 +57,7 @@ from nova import flags from nova import log as logging #from nova import test from nova import utils +from nova import vnc from nova.auth import manager from nova.compute import instance_types from nova.compute import power_state -- cgit From f5c072de1edddc4ddab89be8146a81d361397c45 Mon Sep 17 00:00:00 2001 From: Anthony Young Date: Tue, 29 Mar 2011 14:53:38 -0700 Subject: incorporate feedback from termie --- nova/virt/libvirt_conn.py | 2 -- 1 file changed, 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index 8c948950b..502e61395 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -627,8 +627,6 @@ class LibvirtConnection(driver.ComputeDriver): return {'token': token, 'host': host, 'port': port} - _image_sems = {} # FIXME: why is this here? (anthony) - @staticmethod def _cache_image(fn, target, fname, cow=False, *args, **kwargs): """Wrapper for a method that creates an image that caches the image. -- cgit From 6d3c31df757f65da7b29aaed1fb4d6e2b29126a0 Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 29 Mar 2011 17:17:20 -0700 Subject: Found a better (?) docstring from get_console_pool_info --- nova/virt/driver.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index c6c28b2ba..2f52f9cf1 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -89,7 +89,7 @@ class ComputeDriver(object): raise NotImplementedError() def get_console_pool_info(self, console_type): - """? + """Get info about the host on which the VM resides. Returns a dict containing: :address: ? -- cgit From f0cd8a993d235fddbfb9478b69a77f4ed32f6dff Mon Sep 17 00:00:00 2001 From: Justin Santa Barbara Date: Tue, 29 Mar 2011 17:35:24 -0700 Subject: Wipe out the bad docstring on get_console_pool_info --- nova/virt/driver.py | 8 -------- 1 file changed, 8 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/driver.py b/nova/virt/driver.py index 2f52f9cf1..eb9626d08 100644 --- a/nova/virt/driver.py +++ b/nova/virt/driver.py @@ -89,14 +89,6 @@ class ComputeDriver(object): raise NotImplementedError() def get_console_pool_info(self, console_type): - """Get info about the host on which the VM resides. - - Returns a dict containing: - :address: ? - :username: ? - :password: ? - - """ raise NotImplementedError() def get_console_output(self, instance): -- cgit From 047af2c506374aa44bb896a7df0cb5813bf3a123 Mon Sep 17 00:00:00 2001 From: Thierry Carrez Date: Wed, 30 Mar 2011 15:02:59 +0200 Subject: Add missing method that prevent HyperV compute nodes from starting up --- nova/virt/hyperv.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'nova/virt') diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py index a1ed5ebbf..13f403a66 100644 --- a/nova/virt/hyperv.py +++ b/nova/virt/hyperv.py @@ -485,3 +485,7 @@ class HyperVConnection(driver.ComputeDriver): def poll_rescued_instances(self, timeout): pass + + def update_available_resource(self, ctxt, host): + """This method is supported only by libvirt.""" + return -- cgit From 6f274d0a5818633b072e432ba7182650f0d30001 Mon Sep 17 00:00:00 2001 From: Thierry Carrez Date: Wed, 30 Mar 2011 15:28:21 +0200 Subject: Do not push 'None' to authorized_keys when no key is specified --- nova/virt/libvirt_conn.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index b28584cb6..f34ea7225 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -828,7 +828,10 @@ class LibvirtConnection(driver.ComputeDriver): if FLAGS.libvirt_type == 'lxc': target_partition = None - key = str(inst['key_data']) + if inst['key_data']: + key = str(inst['key_data']) + else: + key = None net = None nets = [] -- cgit From 23776e5b2bdb73df10be590b589c34788c28023a Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 30 Mar 2011 12:28:09 -0500 Subject: Avoid hard dependencies --- nova/virt/vmwareapi_conn.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index 87c3fa299..34d29a4e5 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -43,10 +43,12 @@ from nova import flags from nova import log as logging from nova import utils from nova.virt.vmwareapi import error_util -from nova.virt.vmwareapi import vim from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi.vmops import VMWareVMOps + +vim = None + LOG = logging.getLogger("nova.virt.vmwareapi_conn") FLAGS = flags.FLAGS @@ -78,6 +80,13 @@ flags.DEFINE_string('vmwareapi_vlan_interface', TIME_BETWEEN_API_CALL_RETRIES = 2.0 +def get_imported_vim(): + """Avoid any hard dependencies.""" + global vim + if vim is None: + vim = __import__("nova.virt.vmwareapi.vim") + + class Failure(Exception): """Base Exception class for handling task failures.""" @@ -109,7 +118,7 @@ class VMWareESXConnection(object): def __init__(self, host_ip, host_username, host_password, api_retry_count, scheme="https"): session = VMWareAPISession(host_ip, host_username, host_password, - api_retry_count, scheme=scheme) + api_retry_count, scheme=scheme) self._vmops = VMWareVMOps(session) def init_host(self, host): @@ -204,6 +213,7 @@ class VMWareAPISession(object): self._session_id = None self.vim = None self._create_session() + get_imported_vim() def _get_vim_object(self): """Create the VIM Object instance.""" -- cgit From be4be55bf03c907f46e76fffe3457743915d734a Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 30 Mar 2011 13:50:02 -0500 Subject: Handle in vim.py --- nova/virt/vmwareapi/vim.py | 15 +++++++++++---- nova/virt/vmwareapi_conn.py | 10 ---------- 2 files changed, 11 insertions(+), 14 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index ba14f1512..1c850595d 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -21,10 +21,14 @@ Classes for making VMware VI SOAP calls. import httplib -from suds import WebFault -from suds.client import Client -from suds.plugin import MessagePlugin -from suds.sudsobject import Property +try: + suds = True + from suds import WebFault + from suds.client import Client + from suds.plugin import MessagePlugin + from suds.sudsobject import Property +except ImportError: + suds = False from nova import flags from nova.virt.vmwareapi import error_util @@ -75,6 +79,9 @@ class Vim: protocol: http or https host : ESX IPAddress[:port] or ESX Hostname[:port] """ + if not suds: + raise Exception(_("Unable to import suds.")) + self._protocol = protocol self._host_name = host wsdl_url = FLAGS.vmwareapi_wsdl_loc diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index 34d29a4e5..b909e659d 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -47,8 +47,6 @@ from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi.vmops import VMWareVMOps -vim = None - LOG = logging.getLogger("nova.virt.vmwareapi_conn") FLAGS = flags.FLAGS @@ -80,13 +78,6 @@ flags.DEFINE_string('vmwareapi_vlan_interface', TIME_BETWEEN_API_CALL_RETRIES = 2.0 -def get_imported_vim(): - """Avoid any hard dependencies.""" - global vim - if vim is None: - vim = __import__("nova.virt.vmwareapi.vim") - - class Failure(Exception): """Base Exception class for handling task failures.""" @@ -213,7 +204,6 @@ class VMWareAPISession(object): self._session_id = None self.vim = None self._create_session() - get_imported_vim() def _get_vim_object(self): """Create the VIM Object instance.""" -- cgit From 2eadc55dbd66af7b5adb3c21fe9cc91cd04b0f8b Mon Sep 17 00:00:00 2001 From: Josh Kearney Date: Wed, 30 Mar 2011 13:56:02 -0500 Subject: Whoops --- nova/virt/vmwareapi_conn.py | 1 + 1 file changed, 1 insertion(+) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py index b909e659d..20c1b2b45 100644 --- a/nova/virt/vmwareapi_conn.py +++ b/nova/virt/vmwareapi_conn.py @@ -43,6 +43,7 @@ from nova import flags from nova import log as logging from nova import utils from nova.virt.vmwareapi import error_util +from nova.virt.vmwareapi import vim from nova.virt.vmwareapi import vim_util from nova.virt.vmwareapi.vmops import VMWareVMOps -- cgit From 5d71e187dc6eddab19ecdc0feb97e41263e09a84 Mon Sep 17 00:00:00 2001 From: Brian Lamar Date: Thu, 31 Mar 2011 17:19:59 -0400 Subject: Hopefully absolved us of the suds issue? --- nova/virt/vmwareapi/vim.py | 47 ++++++++++++++++++++++------------------------ 1 file changed, 22 insertions(+), 25 deletions(-) (limited to 'nova/virt') diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py index 1c850595d..159e16a80 100644 --- a/nova/virt/vmwareapi/vim.py +++ b/nova/virt/vmwareapi/vim.py @@ -22,13 +22,9 @@ Classes for making VMware VI SOAP calls. import httplib try: - suds = True - from suds import WebFault - from suds.client import Client - from suds.plugin import MessagePlugin - from suds.sudsobject import Property + import suds except ImportError: - suds = False + suds = None from nova import flags from nova.virt.vmwareapi import error_util @@ -46,24 +42,25 @@ flags.DEFINE_string('vmwareapi_wsdl_loc', 'Refer readme-vmware to setup') -class VIMMessagePlugin(MessagePlugin): +if suds: + class VIMMessagePlugin(suds.plugin.MessagePlugin): - def addAttributeForValue(self, node): - # suds does not handle AnyType properly. - # VI SDK requires type attribute to be set when AnyType is used - if node.name == 'value': - node.set('xsi:type', 'xsd:string') + def addAttributeForValue(self, node): + # suds does not handle AnyType properly. + # VI SDK requires type attribute to be set when AnyType is used + if node.name == 'value': + node.set('xsi:type', 'xsd:string') - def marshalled(self, context): - """suds will send the specified soap envelope. - Provides the plugin with the opportunity to prune empty - nodes and fixup nodes before sending it to the server. - """ - # suds builds the entire request object based on the wsdl schema. - # VI SDK throws server errors if optional SOAP nodes are sent without - # values, e.g. as opposed to test - context.envelope.prune() - context.envelope.walk(self.addAttributeForValue) + def marshalled(self, context): + """suds will send the specified soap envelope. + Provides the plugin with the opportunity to prune empty + nodes and fixup nodes before sending it to the server. + """ + # suds builds the entire request object based on the wsdl schema. + # VI SDK throws server errors if optional SOAP nodes are sent + # without values, e.g. as opposed to test + context.envelope.prune() + context.envelope.walk(self.addAttributeForValue) class Vim: @@ -91,7 +88,7 @@ class Vim: #wsdl_url = '%s://%s/sdk/vimService.wsdl' % (self._protocol, # self._host_name) url = '%s://%s/sdk' % (self._protocol, self._host_name) - self.client = Client(wsdl_url, location=url, + self.client = suds.client.Client(wsdl_url, location=url, plugins=[VIMMessagePlugin()]) self._service_content = \ self.RetrieveServiceContent("ServiceInstance") @@ -134,7 +131,7 @@ class Vim: # check of the SOAP response except error_util.VimFaultException, excep: raise - except WebFault, excep: + except suds.WebFault, excep: doc = excep.document detail = doc.childAtPath("/Envelope/Body/Fault/detail") fault_list = [] @@ -170,7 +167,7 @@ class Vim: """Builds the request managed object.""" # Request Managed Object Builder if type(managed_object) == type(""): - mo = Property(managed_object) + mo = suds.sudsobject.Property(managed_object) mo._type = managed_object else: mo = managed_object -- cgit From ec30c42b3b4532743c8353c5e9fa04ae00803db3 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Mon, 4 Apr 2011 18:31:35 +0400 Subject: network injection check fixed --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index f34ea7225..c952f6f47 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -842,7 +842,7 @@ class LibvirtConnection(driver.ComputeDriver): for (network_ref, mapping) in network_info: ifc_num += 1 - if not 'injected' in network_ref: + if not network_ref.injected: continue have_injected_networks = True -- cgit From 350aaa819c8f97e0bcbd9e4d0f6f0da41784b630 Mon Sep 17 00:00:00 2001 From: Ilya Alekseyev Date: Mon, 4 Apr 2011 22:39:39 +0400 Subject: working with network_ref like with mapping --- nova/virt/libvirt_conn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'nova/virt') diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py index c952f6f47..babbc610d 100644 --- a/nova/virt/libvirt_conn.py +++ b/nova/virt/libvirt_conn.py @@ -842,7 +842,7 @@ class LibvirtConnection(driver.ComputeDriver): for (network_ref, mapping) in network_info: ifc_num += 1 - if not network_ref.injected: + if not network_ref['injected']: continue have_injected_networks = True -- cgit